Garry's Opinionated OpenClaw/Hermes Agent Brain
TypeScript
fix(#7632): narrow to pg_temp last on every gbrain function's search_path (GBRA-108)
garrytane5efb14acd65
diff --git a/docs/ENGINES.md b/docs/ENGINES.mdindex 930d6d617e..6bc5b837da 100644--- a/docs/ENGINES.md+++ b/docs/ENGINES.md@@ -390,36 +390,18 @@ segmented chunk (`test/e2e/segmented-switch-off-write-role.test.ts`). With thepolicies above it creates segmented pages and sees only its sources' rows(`test/e2e/segmented-rls-scope.test.ts`).-**Purge and withdrawal guards.** Seven guard functions read the purge and withdrawal-ledgers (`fact_purges`, `fact_withdrawals`, `take_purges`, `page_purges` and the two-derivation purge tables) as the role that owns them, which ran the migrations: they are-`SECURITY DEFINER` with `search_path = pg_catalog, pg_temp` and name every gbrain table-and function `public.`-qualified (migration v276, #7632). Before, the guards read under the-writing role's RLS, so a write role with no policy on a ledger saw no purge and no-withdrawal: it stored a purged claim again or saved a withdrawn fact active. Nothing-changes for an owner, a role that bypasses RLS or a write role with policies on the-ledgers, and `anon` / `authenticated` gain nothing: EXECUTE on the definers is revoked-from them and from PUBLIC, every definer that refuses fires `AFTER ROW` or-`AFTER STATEMENT`, after RLS has accepted the row, and with `public` off their path a-role that may create functions in `public` cannot plant an overload the owner then runs.-The guards that silently correct a row are unchanged and still run as the writing role:-the derivation drop (`gbrain_refuse_purging_derivation`, `BEFORE ROW`), the-withdrawn-fact stamp on update (`gbrain_preserve_fact_withdrawal`) and the insert guard-(`gbrain_guard_inserted_facts`). A row they pass because the role cannot read a ledger-meets a definer after RLS: `gbrain_refuse_stored_purging_derivation`-(`derivation_purge_pending`), `gbrain_refuse_unguarded_inserted_facts`-(`purged_content`, `fact_withdrawn`) or `gbrain_refuse_revived_withdrawn_fact`-(`fact_withdrawn`). So a scoped write role with no policy on a ledger is now refused, with-an error, where it was let through, and learns whether content it supplies itself is-purged or withdrawn in a source it can already write; one guard also performs a fixed-side effect for it as the owner (adding its page to a running derivation purge's page-list). Every other gbrain function that pins a search_path now ends it with `pg_temp`.-Where the migrating role does not own a guard or its table, the migration names it on-stderr and leaves it; `gbrain doctor` (`guard_functions`) prints the SQL to run as the-owner. An older gbrain binary booting against the brain re-creates-`gbrain_mark_derivation_scope_entry` as an invoker and drops `pg_temp` from the functions-its schema re-creates; `guard_functions` flags both, and the next boot of this release-restores them (`test/e2e/guard-definer-postgres.test.ts`).+**Purge and withdrawal guards.** The guards that refuse purged content and keep withdrawn+facts withdrawn run as the writing role (`SECURITY INVOKER`) and read their ledgers+(`fact_purges`, `fact_withdrawals`, `take_purges`, `page_purges` and the derivation purge+tables) under that role's RLS. Every gbrain function that pins a search_path ends it with+`pg_temp` (migration v276, #7632), so a session's temp table or view named like a ledger+cannot hide it from a guard; before, any session, the owner included, could store purged+content that way. A write role with no policy on a ledger still reads it empty, so its+purged or withdrawn writes still go through: give a scoped write role a `SELECT` policy on+the ledgers of the sources it writes (gbrain#7659 tracks the fix). Where the migrating role+does not own a function, v276 names it on stderr and leaves it; `gbrain doctor`+(`function_search_path`) prints the `ALTER FUNCTION` to run as its owner+(`test/e2e/function-search-path-postgres.test.ts`).**In engine-sql.** A read in a migrated domain takes a `ScopedRead` when itruns through this helper and a `LegacyUnscopedRead` when it runs on the pooldiff --git a/docs/guides/rls-and-you.md b/docs/guides/rls-and-you.mdindex 898b920066..6103e76744 100644--- a/docs/guides/rls-and-you.md+++ b/docs/guides/rls-and-you.md@@ -260,23 +260,16 @@ both with the trigger inert, so a table that relies on either one fails it.## Function search_path-Every plpgsql function gbrain installs pins `search_path = pg_catalog, public, pg_temp`-(`pg_catalog, pg_temp` for the seven guards below), so a same-named object in another schema can never change what the function+Every plpgsql function gbrain installs pins `search_path = pg_catalog, public, pg_temp`,+so a same-named object in another schema can never change what the functionreads or writes. `pg_temp` is named last because PostgreSQL otherwise searches the-caller's temporary schema first for tables and views: a session could shadow a table-a function reads with a temporary one of the same name. On an older brain, migration-v276 appends `pg_temp` to every gbrain function it owns with `ALTER FUNCTION` (no body-changes), and `gbrain doctor` (`guard_functions`) names any function it could not change.--The seven purge and withdrawal guards are also `SECURITY DEFINER`, so they read the purge-and withdrawal ledgers as their owner whatever the writing role's policies are. EXECUTE on-them is revoked from PUBLIC, `anon` and `authenticated`, and they fire after RLS accepts-the row, so a role RLS refuses gets the same refusal whether or not the content was purged-or its source is locked. Their path leaves `public` out and they name every gbrain table-and function `public.`-qualified with exactly typed arguments, so a role that may create-functions in `public` (Supabase grants that to `anon` and `authenticated` on older-projects) cannot plant an overload that runs as the owner. [docs/ENGINES.md](../ENGINES.md) ("Purge and withdrawal guards") has-what changes for a scoped write role. The three fact-fingerprint functions+caller's temporary schema first for tables and views: a session, the owner included,+could shadow a purge or withdrawal ledger a guard reads with an empty temporary one of+the same name and store purged content again. On an older brain, migration v276 appends+`pg_temp` to every gbrain function it owns with `ALTER FUNCTION` (no body changes), and+`gbrain doctor` (`function_search_path`) names any function it could not change, with the+`ALTER FUNCTION` to run as its owner. [docs/ENGINES.md](../ENGINES.md) ("Purge and+withdrawal guards") has what this does not change for a scoped write role. The three fact-fingerprint functions(`gbrain_fact_fingerprint`, `gbrain_fact_fingerprint_v1`,`gbrain_fact_normalize`) are SQL functions that an index expression uses, sothey call `pg_catalog.`-qualified built-ins instead of pinning a setting (adiff --git a/llms-full.txt b/llms-full.txtindex 1a71586055..880fb54c75 100644--- a/llms-full.txt+++ b/llms-full.txt@@ -5836,36 +5836,18 @@ segmented chunk (`test/e2e/segmented-switch-off-write-role.test.ts`). With thepolicies above it creates segmented pages and sees only its sources' rows(`test/e2e/segmented-rls-scope.test.ts`).-**Purge and withdrawal guards.** Seven guard functions read the purge and withdrawal-ledgers (`fact_purges`, `fact_withdrawals`, `take_purges`, `page_purges` and the two-derivation purge tables) as the role that owns them, which ran the migrations: they are-`SECURITY DEFINER` with `search_path = pg_catalog, pg_temp` and name every gbrain table-and function `public.`-qualified (migration v276, #7632). Before, the guards read under the-writing role's RLS, so a write role with no policy on a ledger saw no purge and no-withdrawal: it stored a purged claim again or saved a withdrawn fact active. Nothing-changes for an owner, a role that bypasses RLS or a write role with policies on the-ledgers, and `anon` / `authenticated` gain nothing: EXECUTE on the definers is revoked-from them and from PUBLIC, every definer that refuses fires `AFTER ROW` or-`AFTER STATEMENT`, after RLS has accepted the row, and with `public` off their path a-role that may create functions in `public` cannot plant an overload the owner then runs.-The guards that silently correct a row are unchanged and still run as the writing role:-the derivation drop (`gbrain_refuse_purging_derivation`, `BEFORE ROW`), the-withdrawn-fact stamp on update (`gbrain_preserve_fact_withdrawal`) and the insert guard-(`gbrain_guard_inserted_facts`). A row they pass because the role cannot read a ledger-meets a definer after RLS: `gbrain_refuse_stored_purging_derivation`-(`derivation_purge_pending`), `gbrain_refuse_unguarded_inserted_facts`-(`purged_content`, `fact_withdrawn`) or `gbrain_refuse_revived_withdrawn_fact`-(`fact_withdrawn`). So a scoped write role with no policy on a ledger is now refused, with-an error, where it was let through, and learns whether content it supplies itself is-purged or withdrawn in a source it can already write; one guard also performs a fixed-side effect for it as the owner (adding its page to a running derivation purge's page-list). Every other gbrain function that pins a search_path now ends it with `pg_temp`.-Where the migrating role does not own a guard or its table, the migration names it on-stderr and leaves it; `gbrain doctor` (`guard_functions`) prints the SQL to run as the-owner. An older gbrain binary booting against the brain re-creates-`gbrain_mark_derivation_scope_entry` as an invoker and drops `pg_temp` from the functions-its schema re-creates; `guard_functions` flags both, and the next boot of this release-restores them (`test/e2e/guard-definer-postgres.test.ts`).+**Purge and withdrawal guards.** The guards that refuse purged content and keep withdrawn+facts withdrawn run as the writing role (`SECURITY INVOKER`) and read their ledgers+(`fact_purges`, `fact_withdrawals`, `take_purges`, `page_purges` and the derivation purge+tables) under that role's RLS. Every gbrain function that pins a search_path ends it with+`pg_temp` (migration v276, #7632), so a session's temp table or view named like a ledger+cannot hide it from a guard; before, any session, the owner included, could store purged+content that way. A write role with no policy on a ledger still reads it empty, so its+purged or withdrawn writes still go through: give a scoped write role a `SELECT` policy on+the ledgers of the sources it writes (gbrain#7659 tracks the fix). Where the migrating role+does not own a function, v276 names it on stderr and leaves it; `gbrain doctor`+(`function_search_path`) prints the `ALTER FUNCTION` to run as its owner+(`test/e2e/function-search-path-postgres.test.ts`).**In engine-sql.** A read in a migrated domain takes a `ScopedRead` when itruns through this helper and a `LegacyUnscopedRead` when it runs on the pooldiff --git a/scripts/build-schema.ts b/scripts/build-schema.tsindex 177a08be8e..600f4005e7 100644--- a/scripts/build-schema.ts+++ b/scripts/build-schema.ts@@ -48,7 +48,7 @@ import { FACT_PURGE_LOOKUP_INDEX_SQL, MEMORY_PURGE_SCHEMA_SQL } from '../src/corimport { WRITE_GATE_SCHEMA_SQL } from '../src/core/write-gate-schema.ts';import { BELIEF_LEDGER_SCHEMA_SQL } from '../src/core/belief/schema.ts';import { GIT_CANONICAL_SCHEMA_SQL } from '../src/core/persistence/git-canonical-schema.ts';-import { FUNCTION_SEARCH_PATH_HARDENING_SQL } from '../src/core/guard-definer.ts';+import { FUNCTION_SEARCH_PATH_HARDENING_SQL } from '../src/core/function-search-path.ts';const REPO = resolve(import.meta.dir, '..');export const SCHEMA_SQL_PATH = 'src/schema.sql';@@ -120,7 +120,7 @@ export const FRAGMENTS: readonly Fragment[] = [{ source: 'src/core/questions/schema.ts', expr: 'PINNED_QUESTIONS_SCHEMA_SQL', postgres: PINNED_QUESTIONS_SCHEMA_SQL, pglite: PINNED_QUESTIONS_SCHEMA_SQL },{ source: 'src/core/belief/schema.ts', expr: 'BELIEF_LEDGER_SCHEMA_SQL', postgres: BELIEF_LEDGER_SCHEMA_SQL, pglite: BELIEF_LEDGER_SCHEMA_SQL },// Last: a replay's CREATE OR REPLACE resets each function's search_path, so pg_temp is appended after every one (#7632).- { source: 'src/core/guard-definer.ts', expr: 'FUNCTION_SEARCH_PATH_HARDENING_SQL', postgres: FUNCTION_SEARCH_PATH_HARDENING_SQL, pglite: FUNCTION_SEARCH_PATH_HARDENING_SQL },+ { source: 'src/core/function-search-path.ts', expr: 'FUNCTION_SEARCH_PATH_HARDENING_SQL', postgres: FUNCTION_SEARCH_PATH_HARDENING_SQL, pglite: FUNCTION_SEARCH_PATH_HARDENING_SQL },];const fragmentLabel = (f: Fragment) => `${f.source} (${f.expr})`;diff --git a/scripts/module-size-limits.tsv b/scripts/module-size-limits.tsvindex cfee94c19b..3fe73fd5eb 100644--- a/scripts/module-size-limits.tsv+++ b/scripts/module-size-limits.tsv@@ -47,4 +47,4 @@ src/commands/doctor/checks/extraction-sync.ts 1500 ratchet +7 GBRA-130 A-1: linksrc/core/search/evidence-delivery.ts 1733 ratchet +5 W5: EvidencePlan.rankCut resolved with the plan (logic in search/page-rank-cut.ts); +20 W5 whole_pages: wholeCost prices a block as delivery would emit it whole (needs the private Block/enrichBlock internals) and the cut is wired before allocate (cutWholePages lives in search/page-rank-cut.ts); new row: crossed the 1500 unlisted cap at the #6367 merge (master 1479, its explicit-budget cap) by the C1 date header threaded through every block path, cap included; pagePlanHits (search/page-plan-hits.ts) and the header loader (evidence-date.ts blockDateHeaders) were peeled first; peel candidate: allocateCapped; +8 at the #6396 merge: page evidence text cut through the fence-chunk trust overlay and the caller minTrust floor (re-summed: our 1504 + master +8); +119 Cat 40 next wave F2: the search.long_page_unit policy (withLongPagePolicy, selectLongPages size preflight with page/byte/deadline limits) and the long-page fetch and fallback in deliverEvidence, kept in the shared seam the plan names (gbrain-evals docs/plans/2026-10-11-cat40-next-wave, F2); +17 F2 rework to the frozen-comparison policy: search.long_page_min_chars (rendered-body characters, default 20,000) read in withLongPagePolicy, a character count in the preflight, the rendered-body confirmation in deliverEvidence, and the long-page row exemption in capDeliveredSnippets (re-summed at the 0.60.225.0 merge: master 1537 + F2 136); +39 Wave B PR 2 lane 2b: planSegmentedBlock joins the windows search/segmented-evidence.ts reads around a segmented page's hits into one run-marked document (needs the private Doc/Piece/buildDoc/locateAnchor internals), planBlock's unit cut split into blockFromDoc for both, sections bounded by their run, selectionCost counts a gap between runs, and the fetch skips the whole-body fence overlay for a segmented page; +4 segmented pages read at once before planning (segmentedReads; the read is search/segmented-evidence.ts, the statements page-body/read-range.ts); +17 GBRA-156: tail trim plan flag, DeliverOptions.query, DeliveryMeta.tail_trim, the trim call and the frozen-hit score/query library fields (logic in search/evidence-tail-trim.ts; interface fields cannot move)src/commands/config.ts 1523 ratchet new row: crossed the 1500 unlisted cap in wave 15 P7.4 #5461: set-time validation of think.pages_budget_chars / think.excerpt_ceiling_chars (range + parser live in core/think/pages-budget.ts), mirroring the cycle.consolidate.cluster_threshold hook; +1 wave 16 G5.1 (#6495): set-time refusal hook for search.keyword_statement_timeout_ms (check lives in commands/config/keyword-timeout-value.ts); +1 wave 18b lane 5 (#5012 item 6): search.contextual_retrieval prints the existing-pages hint after the write (text lives in commands/config/contextual-mode-hint.ts); +1 #6712 PR 2: retired/rollback sync key dispatch line (logic in core/sync-config-keys.ts handleSyncKeyConfig); +1 #6865: sync.slug_conflicts.auto_remove boolean validation at set time (refusal text in repair/slug-autoheal.ts); +1 #6948: sync.origin_twins.auto_resolve boolean validation at set time (refusal text in repair/origin-twins-heal.ts); +2 #6795: config set chat_model/expansion_model help line and the model-pin import (shadow report and file-pin unset live in commands/config/model-pin-shadow.ts); +1 #6712 PR 4b: sync.admission set-time hook (value logic in commands/config/sync-admission-value.ts); +4 #7130: set-time refusal hook for sync.max_deletes / sync.max_delete_ratio (and .source.<id>) / purge.retention_hours (check lives in core/sync-reconcile.ts deleteSafetyConfigRefusal); +1 GBRA-150: sync.metafile_pages set-time route (body in config/sync-metafile-pages-value.ts); re-summed at the v0.60.330.0 merge (1520 measured); +2 #7242 minions.terminal_hook file-plane key and its set branch (logic in minions/terminal-hook.ts); +1 GBRA-161: generations.* set-time route (refusal in commands/config/generations-values.ts)src/commands/mcp-expose.ts 1512 ratchet hosted_option: Session carries the gbrain.io coaching notice on the first-receipt run and Tailscale/service friction exits (copy, refs and gating live in core/onboard/hosted-option.ts)-src/core/behavior-change-notice.ts 1508 ratchet the BEHAVIOR_CHANGES table grows by one row per disclosed change: the GBRA-95 RLS backfill row (+2), +3 rows for #7596 pass_interrupted, #7599 read-only serve and the --access=read-only ceiling, +1 G5 lane C trust_release row, and +2 the #7632 guard-definer disclosure row; the behavior-change table split (#7607) retires this row+src/core/behavior-change-notice.ts 1508 ratchet the BEHAVIOR_CHANGES table grows by one row per disclosed change: the GBRA-95 RLS backfill row (+2), +3 rows for #7596 pass_interrupted, #7599 read-only serve and the --access=read-only ceiling, +1 G5 lane C trust_release row, and +2 the #7632 function search_path disclosure row; the behavior-change table split (#7607) retires this rowdiff --git a/scripts/structural-suites.tsv b/scripts/structural-suites.tsvindex a1289fc46a..8c1400538b 100644--- a/scripts/structural-suites.tsv+++ b/scripts/structural-suites.tsv@@ -202,7 +202,6 @@ test/gbrain-owned-page-types.test.ts #5881 gbrain-owned page types are declaredtest/get-page-federated-scope.test.ts #2555 get_chunks federated scope 5 source-surface-helpertest/get-page-federated-scope.test.ts #4275 alias hop scope: archived sources, include_deleted, fuzzy precedence, grant precedence 5 source-surface-helpertest/grant-execution-prerequisites.test.ts execution prerequisite table 1 readFileSync-test/guard-definer-source.test.ts guard definitions keep SECURITY DEFINER (#7632) 2 readFileSynctest/harness-onboarding.test.ts harness identity and private handoff 6 readFileSynctest/hook-command.serial.test.ts user-prompt 18 source-surface-helpertest/hook-push-spawn-env.test.ts spawnDetachedPush env handoff 2 readFileSyncdiff --git a/src/commands/doctor/checks/function-search-path.ts b/src/commands/doctor/checks/function-search-path.tsnew file mode 100644index 0000000000..c1f562f85a--- /dev/null+++ b/src/commands/doctor/checks/function-search-path.ts@@ -0,0 +1,52 @@+/**+ * function_search_path doctor check (#7632): every gbrain function that pins a search_path ends it with pg_temp.+ *+ * Without it, a session's temp table or view named like a ledger (fact_purges, page_purges, take_purges,+ * fact_withdrawals) hides that ledger from the guard that reads it, and a purged or withdrawn write goes through.+ * Migration v276 appends pg_temp to every function the migrating role owns and names the rest on stderr; this check+ * names each function still without it and the ALTER FUNCTION to run as its owner. ALTER FUNCTION ... SET changes+ * neither the owner nor the body, so the next boot's CREATE OR REPLACE still succeeds. Read-only.+ */++import type { BrainEngine } from '../../../core/engine.ts';+import type { Check } from '../../doctor.ts';+import { connectedEngine, type DoctorContext, type DoctorEntry } from '../context.ts';+import { checkError } from '../check-fix.ts';+import { LEGACY_SEARCH_PATH_SETTINGS } from '../../../core/function-search-path.ts';++/** The gbrain functions whose pinned search_path lacks a trailing pg_temp, and the ALTER that fixes each. */+export async function functionSearchPathProblems(engine: BrainEngine): Promise<{ functions: string[]; fix: string[] }> {+ const rows = await engine.executeRaw<{ sig: string; path: string }>(+ `SELECT p.oid::regprocedure::text AS sig, substr(c.setting, 13) AS path+ FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace CROSS JOIN LATERAL unnest(p.proconfig) AS c(setting)+ WHERE n.nspname = 'public' AND c.setting = ANY($1::text[]) ORDER BY 1`,+ [[...LEGACY_SEARCH_PATH_SETTINGS]]);+ return {+ functions: rows.map(r => r.sig),+ fix: rows.map(r => `ALTER FUNCTION ${r.sig} SET search_path = ${r.path}, pg_temp;`),+ };+}++async function runFunctionSearchPath(ctx: DoctorContext): Promise<Check[]> {+ const engine = connectedEngine(ctx);+ const checks: Check[] = [];+ ctx.progress.heartbeat('function_search_path');+ try {+ const { functions, fix } = await functionSearchPathProblems(engine);+ if (functions.length === 0) {+ checks.push({ name: 'function_search_path', status: 'ok', message: 'Every gbrain function that pins a search_path ends it with pg_temp' });+ } else {+ checks.push({+ name: 'function_search_path',+ status: 'fail',+ message: `${functions.length} function(s) pin search_path without pg_temp last (${functions.join(', ')}), so a temp table or view named like a purge or withdrawal ledger hides it from the guard that reads it. `+ + `Fix (as the role that owns each function; migration v276 did the ones the migrating role owned): ${fix.join(' ')}`,+ });+ }+ } catch (e) {+ checks.push(checkError('function_search_path', 'check function search paths', e));+ }+ return checks;+}++export const functionSearchPathEntry: DoctorEntry = { name: 'function_search_path', emits: ['function_search_path'], run: runFunctionSearchPath };diff --git a/src/commands/doctor/checks/guard-functions.ts b/src/commands/doctor/checks/guard-functions.tsdeleted file mode 100644index b2ed6f0f94..0000000000--- a/src/commands/doctor/checks/guard-functions.ts+++ /dev/null@@ -1,103 +0,0 @@-/**- * guard_functions doctor check (#7632): the purge and withdrawal guards read their ledgers as their owner.- *- * Postgres only (PGLite has one role). Fails when one of the seven guards is not SECURITY DEFINER with search_path- * `pg_catalog, pg_temp` (an older gbrain booting against the brain re-creates gbrain_mark_derivation_scope_entry as- * an invoker), is executable by PUBLIC/anon/authenticated, or is owned by a role that does not bypass RLS on a table it- * reads; when a guard's trigger is missing or fires BEFORE ROW; or when any gbrain function's search_path still ends- * without pg_temp.- * Migration v276 makes every change the migrating role owns and names the rest on stderr: this check carries the SQL- * for them, to run as the owning role. Read-only.- */--import type { BrainEngine } from '../../../core/engine.ts';-import type { Check } from '../../doctor.ts';-import { connectedEngine, type DoctorContext, type DoctorEntry } from '../context.ts';-import { checkError } from '../check-fix.ts';-import { DEFINER_GUARDS, GUARD_SEARCH_PATH, LEGACY_SEARCH_PATH_SETTINGS } from '../../../core/guard-definer.ts';-import { GUARD_FUNCTION_SQL, GUARD_TRIGGERS } from '../../../core/schema-migrations/v276-guard-triggers-security-definer.ts';--interface GuardRow { fn: string; secdef: boolean; pinned: boolean; executable_by: string[]; owner: string; reads_under_rls: string[] }--/** What is wrong with the guards on this brain, and the SQL that fixes each, in order. Empty when nothing is. */-export async function guardFunctionProblems(engine: BrainEngine): Promise<{ problems: string[]; fix: string[] }> {- const problems: string[] = [];- const fix: string[] = [];- const reads = DEFINER_GUARDS.map(g => g.reads.join(','));- const guards = await engine.executeRaw<GuardRow>(- `SELECT f.fn, p.prosecdef AS secdef, COALESCE(p.proconfig @> ARRAY[$3::text], false) AS pinned, pg_get_userbyid(p.proowner) AS owner,- ARRAY(SELECT 'PUBLIC' WHERE EXISTS (SELECT 1 FROM aclexplode(COALESCE(p.proacl, acldefault('f', p.proowner))) a- WHERE a.grantee = 0 AND a.privilege_type = 'EXECUTE')- UNION ALL SELECT r.rolname::text FROM pg_roles r- WHERE r.rolname IN ('anon', 'authenticated') AND has_function_privilege(r.oid, p.oid, 'EXECUTE')) AS executable_by,- ARRAY(SELECT c.relname::text FROM unnest(string_to_array(f.reads, ',')) AS t(name) JOIN pg_class c ON c.oid = to_regclass(t.name)- JOIN pg_roles o ON o.oid = p.proowner- WHERE c.relrowsecurity AND NOT o.rolsuper AND NOT o.rolbypassrls AND (c.relowner <> p.proowner OR c.relforcerowsecurity)- ORDER BY 1) AS reads_under_rls- FROM unnest($1::text[], $2::text[]) AS f(fn, reads) JOIN pg_proc p ON p.oid = to_regprocedure(f.fn || '()') ORDER BY f.fn`,- [DEFINER_GUARDS.map(g => g.fn), reads, `search_path=${GUARD_SEARCH_PATH}`]);- for (const g of guards) {- if (!g.secdef || !g.pinned) {- problems.push(`${g.fn}() is not SECURITY DEFINER with search_path ${GUARD_SEARCH_PATH}`);- fix.push(GUARD_FUNCTION_SQL[g.fn]!);- }- if (g.executable_by.length > 0) {- problems.push(`${g.fn}() is executable by ${g.executable_by.join(', ')}`);- fix.push(`REVOKE EXECUTE ON FUNCTION ${g.fn}() FROM ${g.executable_by.join(', ')};`);- }- if (g.reads_under_rls.length > 0) {- problems.push(`${g.fn}()'s owner ${g.owner} neither bypasses RLS nor owns ${g.reads_under_rls.join(', ')} unforced, so the guard reads them filtered`);- fix.push(`/* give ${g.fn}() an owner that bypasses RLS and is not the role gbrain runs as, so that role stays under its policies: ALTER FUNCTION ${g.fn}() OWNER TO <that role>; */`);- }- }- const triggers = await engine.executeRaw<{ table: string; trigger: string; before: boolean | null }>(- `SELECT t.name AS table, g.tgname AS trigger, (g.tgtype & 2) <> 0 AS before- FROM unnest($1::text[]) AS t(name) JOIN pg_class c ON c.oid = to_regclass(t.name)- LEFT JOIN pg_trigger g ON g.tgrelid = c.oid AND NOT g.tgisinternal AND g.tgname = ANY($2::text[])`,- [[...new Set(GUARD_TRIGGERS.map(t => t.table))], GUARD_TRIGGERS.map(t => t.trigger)]);- for (const t of GUARD_TRIGGERS) {- if (!triggers.some(row => row.table === t.table)) continue;- const row = triggers.find(r => r.trigger === t.trigger);- if (row && !row.before) continue;- problems.push(row ? `${t.trigger} on ${t.table} still fires BEFORE ROW` : `${t.table} has no ${t.trigger} AFTER check`);- fix.push(`${GUARD_FUNCTION_SQL[t.fn]}\n${t.sql}`);- }- const unpinned = await engine.executeRaw<{ sig: string; path: string }>(- `SELECT p.oid::regprocedure::text AS sig, substr(c.setting, 13) AS path- FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace CROSS JOIN LATERAL unnest(p.proconfig) AS c(setting)- WHERE n.nspname = 'public' AND c.setting = ANY($1::text[]) AND p.proname <> ALL($2::text[]) ORDER BY 1`,- [[...LEGACY_SEARCH_PATH_SETTINGS], DEFINER_GUARDS.map(g => g.fn)]);- if (unpinned.length > 0) {- problems.push(`${unpinned.length} function(s) pin search_path without pg_temp last (${unpinned.map(u => u.sig).join(', ')})`);- fix.push(...unpinned.map(u => `ALTER FUNCTION ${u.sig} SET search_path = ${u.path}, pg_temp;`));- }- return { problems, fix };-}--async function runGuardFunctions(ctx: DoctorContext): Promise<Check[]> {- const engine = connectedEngine(ctx);- const checks: Check[] = [];- ctx.progress.heartbeat('guard_functions');- if (engine.kind !== 'postgres') {- checks.push({ name: 'guard_functions', status: 'ok', message: 'Skipped (PGLite: one role, so every guard reads every row)' });- return checks;- }- try {- const { problems, fix } = await guardFunctionProblems(engine);- if (problems.length === 0) {- checks.push({ name: 'guard_functions', status: 'ok', message: `The ${DEFINER_GUARDS.length} purge and withdrawal guards read their ledgers as their owner; every gbrain function pins pg_temp last` });- } else {- checks.push({- name: 'guard_functions',- status: 'fail',- message: `${problems.length} guard problem(s): ${problems.join('; ')}. A write role without policies on a ledger can then store purged content or revive a withdrawn fact. `- + `Fix (as the role that owns these functions and tables; migration v276 did what the migrating role owned): ${fix.join(' ')}`,- });- }- } catch (e) {- checks.push(checkError('guard_functions', 'check the purge and withdrawal guards', e));- }- return checks;-}--export const guardFunctionsEntry: DoctorEntry = { name: 'guard_functions', emits: ['guard_functions'], run: runGuardFunctions };diff --git a/src/commands/doctor/registry.ts b/src/commands/doctor/registry.tsindex a8896109d4..9cda613b88 100644--- a/src/commands/doctor/registry.ts+++ b/src/commands/doctor/registry.ts@@ -41,7 +41,7 @@ import {connectionGateEntry,} from './checks/db-connection.ts';import { ipcSocketPathEntry } from './checks/local-ipc.ts';-import { guardFunctionsEntry } from './checks/guard-functions.ts';+import { functionSearchPathEntry } from './checks/function-search-path.ts';import {pgvectorEntry,rlsEntry,@@ -208,7 +208,7 @@ export const DOCTOR_CHECK_REGISTRY: readonly DoctorEntry[] = [// #7276: the privacy check next, with its own entry budget, before any full scan.derivedVisibilityEntry,rlsEntry,- guardFunctionsEntry,+ functionSearchPathEntry,schemaVersionEntry,rlsEventTriggerEntry,embeddingsEntry,diff --git a/src/commands/reindex-search-vector.ts b/src/commands/reindex-search-vector.tsindex c69186a224..b06dafb716 100644--- a/src/commands/reindex-search-vector.ts+++ b/src/commands/reindex-search-vector.ts@@ -48,7 +48,7 @@import type { BrainEngine } from '../core/engine.ts';import { getFtsLanguage, FTS_REINDEX_MARKER_KEY, pageSearchVectorTriggerFnSql, chunkSearchVectorTriggerFnSql } from '../core/fts-language.ts';-import { FUNCTION_SEARCH_PATH_HARDENING_SQL } from '../core/guard-definer.ts';+import { FUNCTION_SEARCH_PATH_HARDENING_SQL } from '../core/function-search-path.ts';import { checkpointKey } from '../core/backfill-base.ts';import { ensureFactsFtsIndex } from '../core/facts/fts-index.ts';import { consentGate } from '../core/consent-cli.ts';@@ -182,7 +182,7 @@ export async function runReindexSearchVector(throw err;}await engine.executeRaw(recreateChunksFn);- // CREATE OR REPLACE reset both functions' search_path; pg_temp goes back last (#7632, guard-definer.ts).+ // CREATE OR REPLACE reset both functions' search_path; pg_temp goes back last (#7632, function-search-path.ts).await engine.executeRaw(FUNCTION_SEARCH_PATH_HARDENING_SQL);const progress = createProgress(cliOptsToProgressOptions(getCliOptions()));diff --git a/src/core/behavior-change-notice.ts b/src/core/behavior-change-notice.tsindex e205826cdd..2d01dde48e 100644--- a/src/core/behavior-change-notice.ts+++ b/src/core/behavior-change-notice.ts@@ -1308,8 +1308,8 @@ export const BEHAVIOR_CHANGES: ReadonlyArray<{ since: string; text: ChangeText;{ since: '0.60.464.0', text: 'Security: `gbrain serve --access=read-only` (the `=` form) now sets the read-only ceiling. It passed flag validation before but started the serve with full write access, because only `--access read-only` was read. A config that used the `=` form now gets the read-only tool set and refused mutations it asked for; a repeated `--access` never widens a read-only value, and an invalid value in either form refuses. `--surface=<v>` likewise now sets the serve surface (it was ignored, leaving the full surface), and a repeated `--surface` takes the narrowest value.' },{ since: '0.60.464.0', text: 'A managed sync pass whose process was killed or crashed now reads `resumable` / `pass_interrupted` in `gbrain sync status` (with an `interrupted` block naming the pass and the dead holder) instead of `pass_unfinished`, and a second killed pass reads `blocked` / `pass_abandoned` at once. `gbrain doctor` `managed_sync_blocked` lists both (warn, fail after an hour). A live pass still committing is no longer counted abandoned because its row is old.' },{ since: '0.60.465.0', text: 'On a managed brain, `gbrain trust release h<id>` of a held fact whose entity page exists now writes the fact into that page\'s `## Facts` fence through the page-write door (a `trust_release` page write) and flips the hold in the same publication, so the released fact lives in the page\'s file and a re-import keeps it. Before, the release inserted a database-only row the file never held; a fence-guard hold that names an existing fence row created a database-only twin of it, and now indexes that row and leaves the file unchanged. The row is stamped `user_confirmed` with origin `trust_release` and the page keeps its trust tier. A hold decided after the release was accepted fails `preview_changed` and writes nothing; a remote request, or a deleted or private entity page, refuses and the fact stays held. A hold with no entity page, and unmanaged brains, release database-only as before.' },- // #7632 guard definers. `since` is stamped at the merge slot.- { since: 'TBD', id: 'guard_triggers_security_definer', text: 'On Postgres, seven guard functions now read the purge and withdrawal ledgers as the role that owns them (`SECURITY DEFINER`, `search_path = pg_catalog, pg_temp`, every gbrain name `public.`-qualified). Before, the guards read under the writing role\'s row-level security, so a write role with no policy on a ledger saw no purge and no withdrawal: a purged claim, page, take or derivation was stored again and a withdrawn fact was saved active. Owners, roles that bypass RLS and write roles with policies on the ledgers see no change: the guards that silently drop a purging derivation and stamp a withdrawn fact expired still run as the writing role, as before. `anon` and `authenticated` gain nothing: EXECUTE on the definers is revoked from PUBLIC, `anon` and `authenticated`; every definer refuses AFTER ROW or AFTER STATEMENT, so RLS refuses a row before any definer reads a ledger; and with `public` off their path, a role that may create functions in `public` cannot plant an overload the owner then runs. A scoped write role with no policy on a ledger is now refused, with an error (`purged_content`, `fact_withdrawn` or `derivation_purge_pending`), where it was let through; it learns whether content it supplies itself is purged or withdrawn in a source it can already write; and one guard performs a fixed side effect for it as the owner (adding its page to a running derivation purge\'s page list). Every other gbrain function that pins a search_path now ends it with `pg_temp` (ALTER only, no body changes). Where the migrating role does not own a guard or its table, the migration names it on stderr and leaves it, and `gbrain doctor` (`guard_functions`) prints the SQL to run as the owner. An older gbrain binary booting against the brain re-creates `gbrain_mark_derivation_scope_entry` as an invoker and drops `pg_temp` from the functions its schema re-creates; `guard_functions` flags both, and the next boot of this release restores them.' },+ // #7632 function search_path. `since` is stamped at the merge slot.+ { since: 'TBD', id: 'function_search_path_pg_temp', text: 'Every gbrain function that pins a search_path now ends it with `pg_temp` (`ALTER FUNCTION ... SET search_path`, no body changes). Before, the purge and withdrawal guards pinned `pg_catalog, public`, which leaves the session\'s temporary schema first for tables and views: any session, the owner included, could create an empty temp table or view named like a ledger (`fact_purges`, `page_purges`, `take_purges`, `fact_withdrawals`, `page_segment_derivation_purges`) and store a purged claim, page, take or derivation again, or save a withdrawn fact active. The guards are otherwise unchanged (SECURITY INVOKER, same bodies, same timing). Still open, not fixed here: on Postgres, a write role with no RLS policy on a ledger reads it empty, so its purged or withdrawn writes still go through (gbrain#7659). Where the migrating role does not own a function, the migration leaves it, names it on stderr and carries on, and `gbrain doctor` (`function_search_path`) prints the `ALTER FUNCTION` to run as its owner; that changes no owner, so later boots still succeed. An older gbrain binary booting against the brain drops `pg_temp` from the functions its schema re-creates; doctor flags them and the next boot of this release puts it back.' },];/** The newest disclosed change's release: the notice id moves only when a release adds rows. */diff --git a/src/core/doctor-categories.ts b/src/core/doctor-categories.tsindex 93ceea5138..71ffac93f4 100644--- a/src/core/doctor-categories.ts+++ b/src/core/doctor-categories.ts@@ -398,8 +398,8 @@ export const OPS_CHECK_NAMES: ReadonlySet<string> = new Set(['grant_new_ops_available','reranker_health','rls',- // #7632: the purge and withdrawal guards read their ledgers as their owner.- 'guard_functions',+ // #7632: every gbrain function that pins a search_path ends it with pg_temp.+ 'function_search_path','rls_event_trigger','search_mode','decide_health',diff --git a/src/core/engine-sql/page-body.ts b/src/core/engine-sql/page-body.tsindex f1f1895428..95af6b37a5 100644--- a/src/core/engine-sql/page-body.ts+++ b/src/core/engine-sql/page-body.ts@@ -490,9 +490,7 @@ export async function readSegmentDerivations(exec: LegacyUnscopedRead, pageId: n* Insert or replace rows keyed (page, kind, occurrence), in statements bounded like manifest rows. A replaced row* keeps its created_at and moves updated_at. Outputs and receipts travel inside the batch's JSON text, never as a* `::jsonb` bind of a stringified value. A row a fact purge's sweep refuses (it holds the purged claim; page-body/schema.ts)- * is not stored, and the call throws DerivationWriteRefused after storing the others. A writer that cannot read the sweep- * records but whose row RLS accepts meets the AFTER ROW check instead: it raises P0001 derivation_purge_pending and that- * batch's statement stores nothing.+ * is not stored, and the call throws DerivationWriteRefused after storing the others.*/export async function upsertSegmentDerivations(exec: SqlExecutor, rows: readonly SegmentDerivationInput[]): Promise<void> {const batches = jsonRowBatches(rows, row => ({diff --git a/src/core/function-search-path.ts b/src/core/function-search-path.tsnew file mode 100644index 0000000000..f0a845c6ac--- /dev/null+++ b/src/core/function-search-path.ts@@ -0,0 +1,35 @@+/**+ * Every gbrain function that pins a search_path ends it with pg_temp (#7632).+ *+ * A pinned `pg_catalog, public` (or `pg_catalog`) does not name pg_temp, and PostgreSQL then searches the calling+ * session's temporary schema first for tables and views. Any role that may create temporary tables (PUBLIC may, by+ * default) could shadow a ledger a guard reads, such as fact_purges, page_purges, take_purges or fact_withdrawals, with an+ * empty temp table or view of the same name, and the guard let a purged claim, page or take, or a withdrawn fact,+ * through: for the owner as much as for any other writer. Named last, pg_temp comes after every other schema for+ * relations, and PostgreSQL never searches it for functions or operators.+ *+ * ALTER FUNCTION only: no body is rewritten, so every guard keeps master's body, SECURITY INVOKER and BEFORE ROW timing.+ * A write role with no policy on a ledger still reads it empty under its own RLS; that fail-open stays open (#7659).+ */++/** The search_path settings gbrain functions pinned before #7632, which the hardening completes with pg_temp. */+export const LEGACY_SEARCH_PATH_SETTINGS = ['search_path=pg_catalog, public', 'search_path=pg_catalog'] as const;++/**+ * Appends pg_temp to the pinned search_path of every function in public the current role may alter that still pins+ * `pg_catalog, public` or `pg_catalog` (every gbrain function that pins one did). A function the role does not own is+ * left as it was. Shared by the schema blob (its last statement, so a replay's CREATE OR REPLACE never leaves a function+ * without it), the migration and `gbrain reindex-search-vector`, which rewrites the search_vector trigger functions.+ */+export const FUNCTION_SEARCH_PATH_HARDENING_SQL = `DO $harden$+DECLARE f RECORD;+BEGIN+ FOR f IN SELECT p.oid::regprocedure AS sig, substr(c.setting, 13) AS path+ FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace CROSS JOIN LATERAL unnest(p.proconfig) AS c(setting)+ WHERE n.nspname = 'public' AND c.setting IN (${LEGACY_SEARCH_PATH_SETTINGS.map(v => `'${v}'`).join(', ')})+ AND pg_has_role(current_user, p.proowner, 'USAGE')+ ORDER BY 1+ LOOP+ EXECUTE format('ALTER FUNCTION %s SET search_path = %s, pg_temp', f.sig, f.path);+ END LOOP;+END $harden$;`;diff --git a/src/core/guard-definer.ts b/src/core/guard-definer.tsdeleted file mode 100644index 8c5888a256..0000000000--- a/src/core/guard-definer.ts+++ /dev/null@@ -1,218 +0,0 @@-/**- * Guard trigger functions that read RLS-protected lookup tables run as their owner (#7632).- *- * The purge and withdrawal guards decide a write by reading another table (a purge or withdrawal ledger). As- * SECURITY INVOKER they read it under the writing role's row-level security, so a role that may write the guarded- * table but has no policy on the ledger read zero rows and the guard let the write through: a purged claim, page,- * take or derivation was stored again, and a withdrawn fact was saved active. The definers below read the ledger as- * their owner (the role that ran the migrations, which owns the tables and bypasses RLS) whatever the writer's- * policies are.- *- * The trust model around that, each piece pinned by test/e2e/guard-definer-postgres.test.ts:- * - A definer runs with search_path = pg_catalog, pg_temp and names every gbrain table and function as public.x.- * PostgreSQL never searches pg_temp for functions or operators, and public is off the path, so a role with CREATE- * on public (Supabase grants it to anon and authenticated) cannot plant an overload of a built-in the owner then- * runs; and pg_temp last keeps a caller's temp table or view named like a ledger out of every relation lookup.- * Every other gbrain function gets pg_temp appended (FUNCTION_SEARCH_PATH_HARDENING_SQL): an invoker guard can- * otherwise be walked past with a temp table named like its ledger. Those run as the caller, so an overload there- * runs with the caller's own rights.- * - A definer never writes a table whose triggers run invoker functions: a definer's write fires them as the owner,- * with public on their path. Only gbrain_mark_derivation_scope_entry writes (page_segment_derivation_purge_pages,- * which has no trigger).- * - EXECUTE is revoked from PUBLIC, anon and authenticated. A trigger function cannot be called directly anyway, and a- * trigger fires whatever the EXECUTE grants are.- * - A definer never answers before RLS has accepted the row: BEFORE ROW triggers run before RLS WITH CHECK, so a- * definer there would tell a role with a bare INSERT grant (Supabase anon) purged content from other content, or a- * locked source from an absent one. Every definer that refuses fires AFTER ROW or AFTER STATEMENT. The guards that- * silently correct a row stay master's invokers, BEFORE ROW or writing as the writer: gbrain_refuse_purging_derivation- * drops a derivation a sweep would delete, gbrain_preserve_fact_withdrawal stamps a withdrawn fact expired, and- * gbrain_guard_inserted_facts refuses purged inserts and stamps withdrawn ones. A row they pass because the writer- * cannot read the ledger meets a definer after RLS: gbrain_refuse_stored_purging_derivation- * (derivation_purge_pending), gbrain_refuse_unguarded_inserted_facts and gbrain_refuse_revived_withdrawn_fact- * (purged_content, fact_withdrawn).- *- * What a writer gains: one fixed side effect the owner performs for it (adding its page to a running derivation- * purge's page list) and knowing whether content it supplies is purged or withdrawn in a source it can already write.- * anon and authenticated gain nothing: RLS refuses their row before any definer reads a ledger. A writer RLS accepts- * but with no policy on a ledger is refused where it used to fail open, with an error instead of a silent drop or- * stamp.- */--/** The seven definer guards and the tables each reads, besides the one its trigger is on. */-export const DEFINER_GUARDS = [- { fn: 'gbrain_mark_derivation_scope_entry', reads: ['page_segment_derivation_purges', 'page_segment_derivation_purge_pages'] },- { fn: 'gbrain_refuse_purged_fact', reads: ['fact_purges', 'sources'] },- { fn: 'gbrain_refuse_purged_page', reads: ['page_purges'] },- { fn: 'gbrain_refuse_purged_take', reads: ['take_purges', 'pages'] },- { fn: 'gbrain_refuse_revived_withdrawn_fact', reads: ['fact_withdrawals', 'sources'] },- { fn: 'gbrain_refuse_stored_purging_derivation', reads: ['page_segment_derivation_purges', 'pages', 'page_body_manifest'] },- { fn: 'gbrain_refuse_unguarded_inserted_facts', reads: ['fact_purges', 'fact_withdrawals', 'facts', 'sources'] },-] as const;--export const GUARD_SEARCH_PATH = 'pg_catalog, pg_temp';--/** The Data API roles Supabase grants EXECUTE on new functions through default privileges. */-const API_ROLES = ['anon', 'authenticated'] as const;--/** Revokes EXECUTE on a zero-argument function from PUBLIC and from the Data API roles that exist. */-export function revokeExecuteSql(fn: string): string {- return `REVOKE EXECUTE ON FUNCTION ${fn}() FROM PUBLIC;-DO $revoke$ BEGIN-${API_ROLES.map(r => ` IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = '${r}') THEN REVOKE EXECUTE ON FUNCTION ${fn}() FROM ${r}; END IF;`).join('\n')}-END $revoke$;`;-}--/** Refuses an update into a purged claim; AFTER ROW, after RLS. Inserts meet gbrain_refuse_unguarded_inserted_facts. */-const REFUSE_PURGED_FACT_SQL = `CREATE OR REPLACE FUNCTION gbrain_refuse_purged_fact() RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path = ${GUARD_SEARCH_PATH} AS $fn$-BEGIN- PERFORM s.id FROM public.sources s WHERE s.id = NEW.source_id FOR SHARE;- IF EXISTS (SELECT 1 FROM public.fact_purges p- WHERE p.source_id = NEW.source_id AND p.visibility = NEW.visibility- AND (p.subject = '*'::text OR p.subject = NEW.entity_slug)- AND p.fact_hash = public.gbrain_fact_fingerprint(NEW.fact)) THEN- RAISE EXCEPTION USING ERRCODE = 'P0001',- MESSAGE = 'purged_content: this claim was purged from this source and cannot be saved again',- DETAIL = json_build_object('table'::text, 'facts'::text, 'hash8'::text, left(public.gbrain_fact_fingerprint(NEW.fact), 8))::text;- END IF;- RETURN NULL;-END-$fn$;-${revokeExecuteSql('gbrain_refuse_purged_fact')}`;--const REFUSE_PURGED_TAKE_SQL = `CREATE OR REPLACE FUNCTION gbrain_refuse_purged_take() RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path = ${GUARD_SEARCH_PATH} AS $fn$-DECLARE src TEXT; subj TEXT;-BEGIN- SELECT p.source_id, p.slug INTO src, subj FROM public.pages p WHERE p.id = NEW.page_id;- IF src IS NOT NULL AND EXISTS (SELECT 1 FROM public.take_purges t- WHERE t.source_id = src AND (t.subject = '*'::text OR t.subject = subj)- AND t.claim_hash = public.gbrain_fact_fingerprint(NEW.claim)) THEN- RAISE EXCEPTION USING ERRCODE = 'P0001',- MESSAGE = 'purged_content: this take claim was purged from this source and cannot be saved again',- DETAIL = json_build_object('table'::text, 'takes'::text, 'hash8'::text, left(public.gbrain_fact_fingerprint(NEW.claim), 8))::text;- END IF;- RETURN NULL;-END-$fn$;-${revokeExecuteSql('gbrain_refuse_purged_take')}`;--const REFUSE_PURGED_PAGE_SQL = `CREATE OR REPLACE FUNCTION gbrain_refuse_purged_page() RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path = ${GUARD_SEARCH_PATH} AS $fn$-BEGIN- -- No column list on the trigger: a column-scoped trigger would pin pages.source_id and content_hash.- IF NEW.content_hash IS NOT NULL- AND (TG_OP = 'INSERT' OR NEW.content_hash IS DISTINCT FROM OLD.content_hash OR NEW.source_id IS DISTINCT FROM OLD.source_id)- AND EXISTS (SELECT 1 FROM public.page_purges p WHERE p.source_id = NEW.source_id AND p.content_hash = NEW.content_hash) THEN- RAISE EXCEPTION USING ERRCODE = 'P0001',- MESSAGE = 'purged_content: this page content was purged from this source and cannot be saved again',- DETAIL = json_build_object('table'::text, 'pages'::text, 'hash8'::text, left(NEW.content_hash, 8))::text;- END IF;- RETURN NULL;-END-$fn$;-${revokeExecuteSql('gbrain_refuse_purged_page')}`;--/**- * Refuses an update that leaves a withdrawn fact active. gbrain_preserve_fact_withdrawal (BEFORE ROW, invoker) stamps- * it expired for a writer that can read fact_withdrawals, so only a writer that cannot meets this.- */-const REFUSE_REVIVED_WITHDRAWN_FACT_SQL = `CREATE OR REPLACE FUNCTION gbrain_refuse_revived_withdrawn_fact() RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path = ${GUARD_SEARCH_PATH} AS $fn$-BEGIN- PERFORM s.id FROM public.sources s WHERE s.id = NEW.source_id FOR SHARE;- IF EXISTS (SELECT 1 FROM public.fact_withdrawals w- WHERE w.source_id = NEW.source_id AND w.visibility = NEW.visibility- AND (w.subject = '*'::text OR w.subject = NEW.entity_slug)- AND w.fact_hash IN (public.gbrain_fact_fingerprint(NEW.fact), public.gbrain_fact_fingerprint_v1(NEW.fact))) THEN- RAISE EXCEPTION USING ERRCODE = 'P0001',- MESSAGE = 'fact_withdrawn: this fact was withdrawn from this source and cannot be made active again';- END IF;- RETURN NULL;-END-$fn$;-${revokeExecuteSql('gbrain_refuse_revived_withdrawn_fact')}`;--/**- * Refuses an insert that leaves a purged fact stored or a withdrawn fact active. Fires after facts_guard_inserted- * (gbrain_guard_inserted_facts, invoker: it refuses and stamps what the writer can read), so only a writer that cannot- * read the ledgers meets it. Reads only: a definer's write would run the facts triggers as the owner.- */-const REFUSE_UNGUARDED_INSERTED_FACTS_SQL = `CREATE OR REPLACE FUNCTION gbrain_refuse_unguarded_inserted_facts() RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path = ${GUARD_SEARCH_PATH} AS $fn$-DECLARE purged TEXT;-BEGIN- PERFORM s.id FROM public.sources s WHERE s.id IN (SELECT i.source_id FROM inserted_facts i) ORDER BY s.id FOR SHARE OF s;- IF EXISTS (SELECT 1 FROM public.fact_purges p WHERE p.source_id IN (SELECT i.source_id FROM inserted_facts i)) THEN- SELECT n.fact_hash INTO purged FROM (SELECT i.source_id, i.visibility, i.entity_slug, public.gbrain_fact_fingerprint(i.fact) AS fact_hash- FROM inserted_facts i) n- WHERE EXISTS (SELECT 1 FROM public.fact_purges p WHERE p.source_id = n.source_id AND p.visibility = n.visibility- AND p.subject IN ('*'::text, n.entity_slug) AND p.fact_hash = n.fact_hash)- LIMIT 1;- IF purged IS NOT NULL THEN- RAISE EXCEPTION USING ERRCODE = 'P0001',- MESSAGE = 'purged_content: this claim was purged from this source and cannot be saved again',- DETAIL = json_build_object('table'::text, 'facts'::text, 'hash8'::text, left(purged, 8))::text;- END IF;- END IF;- IF EXISTS (SELECT 1 FROM public.fact_withdrawals w WHERE w.source_id IN (SELECT i.source_id FROM inserted_facts i)) THEN- IF EXISTS (SELECT 1 FROM inserted_facts i JOIN public.facts f ON f.id = i.id- WHERE f.expired_at IS NULL AND EXISTS (SELECT 1 FROM public.fact_withdrawals w- WHERE w.source_id = f.source_id AND w.visibility = f.visibility AND w.subject IN ('*'::text, f.entity_slug)- AND w.fact_hash IN (public.gbrain_fact_fingerprint(f.fact), public.gbrain_fact_fingerprint_v1(f.fact)))) THEN- RAISE EXCEPTION USING ERRCODE = 'P0001',- MESSAGE = 'fact_withdrawn: this fact was withdrawn from this source and cannot be saved active';- END IF;- END IF;- RETURN NULL;-END-$fn$;-${revokeExecuteSql('gbrain_refuse_unguarded_inserted_facts')}`;--/** The definer guards on facts, takes and pages, by function: CREATE OR REPLACE with the body, then the revoke. */-export const DEFINER_FUNCTION_SQL: Readonly<Record<string, string>> = {- gbrain_refuse_purged_fact: REFUSE_PURGED_FACT_SQL,- gbrain_refuse_purged_take: REFUSE_PURGED_TAKE_SQL,- gbrain_refuse_purged_page: REFUSE_PURGED_PAGE_SQL,- gbrain_refuse_revived_withdrawn_fact: REFUSE_REVIVED_WITHDRAWN_FACT_SQL,- gbrain_refuse_unguarded_inserted_facts: REFUSE_UNGUARDED_INSERTED_FACTS_SQL,-};--/**- * Their triggers, all AFTER so RLS refuses a row first. The three purge triggers keep their events and columns; the- * two new ones follow facts_guard_inserted and facts_preserve_withdrawal (AFTER STATEMENT triggers fire in name order).- */-export const DEFINER_TRIGGERS = [- { table: 'facts', trigger: 'facts_refuse_purged', fn: 'gbrain_refuse_purged_fact', sql: `DROP TRIGGER IF EXISTS facts_refuse_purged ON facts;-CREATE TRIGGER facts_refuse_purged AFTER UPDATE OF fact, source_id, visibility, entity_slug ON facts- FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_fact();` },- { table: 'takes', trigger: 'takes_refuse_purged', fn: 'gbrain_refuse_purged_take', sql: `DROP TRIGGER IF EXISTS takes_refuse_purged ON takes;-CREATE TRIGGER takes_refuse_purged AFTER INSERT OR UPDATE OF claim, page_id ON takes- FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_take();` },- { table: 'pages', trigger: 'pages_refuse_purged', fn: 'gbrain_refuse_purged_page', sql: `DROP TRIGGER IF EXISTS pages_refuse_purged ON pages;-CREATE TRIGGER pages_refuse_purged AFTER INSERT OR UPDATE ON pages- FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_page();` },- { table: 'facts', trigger: 'facts_refuse_revived_withdrawal', fn: 'gbrain_refuse_revived_withdrawn_fact', sql: `DROP TRIGGER IF EXISTS facts_refuse_revived_withdrawal ON facts;-CREATE TRIGGER facts_refuse_revived_withdrawal AFTER UPDATE OF fact, source_id, visibility, entity_slug, expired_at ON facts- FOR EACH ROW WHEN (NEW.expired_at IS NULL) EXECUTE FUNCTION gbrain_refuse_revived_withdrawn_fact();` },- { table: 'facts', trigger: 'facts_refuse_unguarded_inserted', fn: 'gbrain_refuse_unguarded_inserted_facts', sql: `DROP TRIGGER IF EXISTS facts_refuse_unguarded_inserted ON facts;-CREATE TRIGGER facts_refuse_unguarded_inserted AFTER INSERT ON facts REFERENCING NEW TABLE AS inserted_facts- FOR EACH STATEMENT EXECUTE FUNCTION gbrain_refuse_unguarded_inserted_facts();` },-] as const;--/** The search_path settings gbrain functions pinned before #7632, which the hardening completes with pg_temp. */-export const LEGACY_SEARCH_PATH_SETTINGS = ['search_path=pg_catalog, public', 'search_path=pg_catalog'] as const;--/**- * Appends pg_temp to the pinned search_path of every function in public the current role may alter that still pins- * `pg_catalog, public` or `pg_catalog` (every gbrain function that pins one did). ALTER only: no body is rewritten.- * Shared by the schema blob (its last statement, so a replay's CREATE OR REPLACE never leaves a function without it),- * the migration and `gbrain reindex-search-vector`, which rewrites the search_vector trigger functions.- */-export const FUNCTION_SEARCH_PATH_HARDENING_SQL = `DO $harden$-DECLARE f RECORD;-BEGIN- FOR f IN SELECT p.oid::regprocedure AS sig, substr(c.setting, 13) AS path- FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace CROSS JOIN LATERAL unnest(p.proconfig) AS c(setting)- WHERE n.nspname = 'public' AND c.setting IN (${LEGACY_SEARCH_PATH_SETTINGS.map(v => `'${v}'`).join(', ')})- AND pg_has_role(current_user, p.proowner, 'USAGE')- ORDER BY 1- LOOP- EXECUTE format('ALTER FUNCTION %s SET search_path = %s, pg_temp', f.sig, f.path);- END LOOP;-END $harden$;`;diff --git a/src/core/page-body/schema.ts b/src/core/page-body/schema.tsindex 49b372ec03..87bc974968 100644--- a/src/core/page-body/schema.ts+++ b/src/core/page-body/schema.ts@@ -10,8 +10,6 @@* are NULL, which v248's DROP NOT NULL is the first to permit.*/-import { GUARD_SEARCH_PATH, revokeExecuteSql } from '../guard-definer.ts';-/*** Query-cache generation bump (v0.40.3.0, migration v91's trigger function).* BEFORE INSERT OR UPDATE so every write path bumps generation (D6 / codex #4).@@ -213,7 +211,7 @@ export function derivationHoldsClaimSql(d: string, needles: string, patterns: stLATERAL (SELECT jsonb_path_query(doc.j, 'strict $.** ? (@.type() == "string")') #>> '{}' AS tUNION ALL SELECT jsonb_path_query(doc.j, 'strict $.** ? (@.type() == "object").keyvalue().key') #>> '{}') sWHERE CASE WHEN ${hasWordsSql('s.t', patterns)} THEN EXISTS (SELECT 1 FROM unnest(${needles}::text[]) k(n)- WHERE strpos(' ' || ${foldSql('public.gbrain_fact_normalize(s.t)')} || ' ', k.n) > 0) ELSE false END) ELSE false END`;+ WHERE strpos(' ' || ${foldSql('gbrain_fact_normalize(s.t)')} || ' ', k.n) > 0) ELSE false END) ELSE false END`;}/**@@ -223,7 +221,7 @@ export function derivationHoldsClaimSql(d: string, needles: string, patterns: st* that page's prose still says, and the next derivation would write it back.*/export function derivationSweepScopeSql(d: string, p: string, pageIds: string): string {- return `(${d}.page_id = ANY(${pageIds}::int[]) OR ${p}.deleted_at IS NOT NULL OR NOT EXISTS (SELECT 1 FROM public.page_body_manifest m+ return `(${d}.page_id = ANY(${pageIds}::int[]) OR ${p}.deleted_at IS NOT NULL OR NOT EXISTS (SELECT 1 FROM page_body_manifest mWHERE m.page_id = ${d}.page_id AND m.occurrence_id = ${d}.occurrence_id AND m.gen_to IS NULL AND m.staging_id IS NULL AND m.sha256 = ${d}.segment_sha256))`;}@@ -236,59 +234,9 @@ export function derivationSweepScopeSql(d: string, p: string, pageIds: string):* and otherwise waits a bounded time in a transaction that holds no other lock (segment-derive.ts continueDerivationPurges).*/export function derivationScopeLockSql(sourceId: string): string {- return `hashtextextended('gbrain:derivation-scope:'::text || ${sourceId}, 0::bigint)`;+ return `hashtextextended('gbrain:derivation-scope:' || ${sourceId}, 0)`;}-/**- * The derivation guard's AFTER ROW half (#7632): raises derivation_purge_pending for a stored row that a fact purge's- * sweep would delete. The BEFORE ROW half (gbrain_refuse_purging_derivation) runs as the writer and drops such a row- * silently, so this one fires only for a row that passed it unseen and that RLS then accepted: a writer with no policy- * on the sweep records. It reads them as its owner, so that writer is refused instead of storing the row; a role RLS- * refuses never reaches it, so it learns nothing about a sweep.- */-export const DERIVATION_STORED_GUARD_FUNCTION_SQL = `CREATE OR REPLACE FUNCTION gbrain_refuse_stored_purging_derivation() RETURNS trigger SECURITY DEFINER SET search_path = ${GUARD_SEARCH_PATH} AS $func$-BEGIN- IF EXISTS (SELECT 1 FROM public.page_segment_derivation_purges x JOIN public.pages p ON p.source_id = x.source_id- WHERE p.id = NEW.page_id AND ${derivationSweepScopeSql('NEW', 'p', 'x.page_ids')}- AND ${derivationHoldsClaimSql('NEW', 'x.needles', 'x.patterns')}) THEN- RAISE EXCEPTION USING ERRCODE = 'P0001',- MESSAGE = 'derivation_purge_pending: a fact purge''s sweep of stored derivation results is still running and this row holds its claim',- DETAIL = json_build_object('table'::text, 'page_segment_derivations'::text)::text;- END IF;- RETURN NULL;-END-$func$ LANGUAGE plpgsql;-${revokeExecuteSql('gbrain_refuse_stored_purging_derivation')}`;--export const DERIVATION_STORED_GUARD_TRIGGER_SQL = `DROP TRIGGER IF EXISTS page_segment_derivations_refuse_stored_purging ON page_segment_derivations;-CREATE TRIGGER page_segment_derivations_refuse_stored_purging AFTER INSERT OR UPDATE OF output, receipt ON page_segment_derivations- FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_stored_purging_derivation();`;--/**- * The scope-entry trigger function (#7632 definer): notes a page entering a running sweep's scope for every sweep of- * its source, as the owner, so a writer without a policy on the sweep records still notes it. It writes only- * page_segment_derivation_purge_pages, which has no trigger (a definer's write runs a table's triggers as the owner).- */-export const DERIVATION_SCOPE_ENTRY_FUNCTION_SQL = `CREATE OR REPLACE FUNCTION gbrain_mark_derivation_scope_entry() RETURNS trigger SECURITY DEFINER SET search_path = ${GUARD_SEARCH_PATH} AS $func$-DECLARE- src TEXT;- page INTEGER;-BEGIN- IF TG_TABLE_NAME = 'pages' THEN- src := NEW.source_id;- page := NEW.id;- ELSE- src := OLD.source_id;- page := OLD.page_id;- END IF;- PERFORM pg_advisory_xact_lock_shared(${derivationScopeLockSql('src')});- INSERT INTO public.page_segment_derivation_purge_pages (request_id, page_id)- SELECT x.request_id, page FROM public.page_segment_derivation_purges x WHERE x.source_id = src ON CONFLICT DO NOTHING;- RETURN NULL;-END-$func$ LANGUAGE plpgsql;-${revokeExecuteSql('gbrain_mark_derivation_scope_entry')}`;-/*** Per-segment derivation watermarks (migration v273): one row per page, pipeline and manifest occurrence, recording* the segment text and the context (`context_hash`: entry state plus the page-level inputs the pipeline reads) it was@@ -309,10 +257,7 @@ ${revokeExecuteSql('gbrain_mark_derivation_scope_entry')}`;* before the purge committed is refused by its own generation guard instead. A row can also enter the scope without a* write, when its occurrence is retired or its page soft-deleted: the triggers on page_body_manifest and pages note the* page in page_segment_derivation_purge_pages for every sweep of the source, and the sweep checks those pages again- * before it ends. The dropping trigger reads the sweep records as the writer, as RLS lets it; a row it passes unseen- * that RLS accepts meets DERIVATION_STORED_GUARD_FUNCTION_SQL, which reads them as its owner and refuses the write- * (derivation_purge_pending). The scope-entry trigger reads and notes them as its owner (SECURITY DEFINER,- * ../guard-definer.ts). A role RLS refuses meets neither definer, so it learns nothing about a sweep.+ * before it ends.** PR 4 (Wave B incremental derivation, transcripts): page_derivation_spend is the per-page lifetime spend ledger of each* paid derivation family (`facts`, `synopsis`; page-spend.ts), each capped by `derive.max_usd_per_page` on its own,@@ -366,7 +311,24 @@ CREATE TABLE IF NOT EXISTS page_segment_derivation_purge_pages (page_id INTEGER NOT NULL,PRIMARY KEY (request_id, page_id));-${DERIVATION_SCOPE_ENTRY_FUNCTION_SQL}+CREATE OR REPLACE FUNCTION gbrain_mark_derivation_scope_entry() RETURNS trigger SET search_path = pg_catalog, public AS $func$+DECLARE+ src TEXT;+ page INTEGER;+BEGIN+ IF TG_TABLE_NAME = 'pages' THEN+ src := NEW.source_id;+ page := NEW.id;+ ELSE+ src := OLD.source_id;+ page := OLD.page_id;+ END IF;+ PERFORM pg_advisory_xact_lock_shared(${derivationScopeLockSql('src')});+ INSERT INTO page_segment_derivation_purge_pages (request_id, page_id)+ SELECT x.request_id, page FROM page_segment_derivation_purges x WHERE x.source_id = src ON CONFLICT DO NOTHING;+ RETURN NULL;+END+$func$ LANGUAGE plpgsql;DROP TRIGGER IF EXISTS page_body_manifest_derivation_scope_retire ON page_body_manifest;CREATE TRIGGER page_body_manifest_derivation_scope_retire AFTER UPDATE OF gen_to ON page_body_manifestFOR EACH ROW WHEN (OLD.gen_to IS NULL AND NEW.gen_to IS NOT NULL AND OLD.staging_id IS NULL) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry();@@ -388,9 +350,7 @@ END$func$ LANGUAGE plpgsql;DROP TRIGGER IF EXISTS page_segment_derivations_refuse_purging ON page_segment_derivations;CREATE TRIGGER page_segment_derivations_refuse_purging BEFORE INSERT OR UPDATE OF output, receipt ON page_segment_derivations- FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purging_derivation();-${DERIVATION_STORED_GUARD_FUNCTION_SQL}-${DERIVATION_STORED_GUARD_TRIGGER_SQL}`;+ FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purging_derivation();`;/*** The segment tables hold page text (`page_segment_texts`, `page_body_staging_parts`) or a page's shape anddiff --git a/src/core/pglite-schema.generated.ts b/src/core/pglite-schema.generated.tsindex e3b18be0b7..e6358c1604 100644--- a/src/core/pglite-schema.generated.ts+++ b/src/core/pglite-schema.generated.ts@@ -1515,7 +1515,7 @@ CREATE TABLE IF NOT EXISTS page_segment_derivation_purge_pages (page_id INTEGER NOT NULL,PRIMARY KEY (request_id, page_id));-CREATE OR REPLACE FUNCTION gbrain_mark_derivation_scope_entry() RETURNS trigger SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS \$func\$+CREATE OR REPLACE FUNCTION gbrain_mark_derivation_scope_entry() RETURNS trigger SET search_path = pg_catalog, public AS \$func\$DECLAREsrc TEXT;page INTEGER;@@ -1527,17 +1527,12 @@ BEGINsrc := OLD.source_id;page := OLD.page_id;END IF;- PERFORM pg_advisory_xact_lock_shared(hashtextextended('gbrain:derivation-scope:'::text || src, 0::bigint));- INSERT INTO public.page_segment_derivation_purge_pages (request_id, page_id)- SELECT x.request_id, page FROM public.page_segment_derivation_purges x WHERE x.source_id = src ON CONFLICT DO NOTHING;+ PERFORM pg_advisory_xact_lock_shared(hashtextextended('gbrain:derivation-scope:' || src, 0));+ INSERT INTO page_segment_derivation_purge_pages (request_id, page_id)+ SELECT x.request_id, page FROM page_segment_derivation_purges x WHERE x.source_id = src ON CONFLICT DO NOTHING;RETURN NULL;END\$func\$ LANGUAGE plpgsql;-REVOKE EXECUTE ON FUNCTION gbrain_mark_derivation_scope_entry() FROM PUBLIC;-DO \$revoke\$ BEGIN- IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'anon') THEN REVOKE EXECUTE ON FUNCTION gbrain_mark_derivation_scope_entry() FROM anon; END IF;- IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'authenticated') THEN REVOKE EXECUTE ON FUNCTION gbrain_mark_derivation_scope_entry() FROM authenticated; END IF;-END \$revoke\$;DROP TRIGGER IF EXISTS page_body_manifest_derivation_scope_retire ON page_body_manifest;CREATE TRIGGER page_body_manifest_derivation_scope_retire AFTER UPDATE OF gen_to ON page_body_manifestFOR EACH ROW WHEN (OLD.gen_to IS NULL AND NEW.gen_to IS NOT NULL AND OLD.staging_id IS NULL) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry();@@ -1550,13 +1545,13 @@ CREATE TRIGGER pages_derivation_scope_delete AFTER UPDATE OF deleted_at ON pagesCREATE OR REPLACE FUNCTION gbrain_refuse_purging_derivation() RETURNS trigger SET search_path = pg_catalog, public AS \$func\$BEGINIF EXISTS (SELECT 1 FROM page_segment_derivation_purges x JOIN pages p ON p.source_id = x.source_id- WHERE p.id = NEW.page_id AND (NEW.page_id = ANY(x.page_ids::int[]) OR p.deleted_at IS NOT NULL OR NOT EXISTS (SELECT 1 FROM public.page_body_manifest m+ WHERE p.id = NEW.page_id AND (NEW.page_id = ANY(x.page_ids::int[]) OR p.deleted_at IS NOT NULL OR NOT EXISTS (SELECT 1 FROM page_body_manifest mWHERE m.page_id = NEW.page_id AND m.occurrence_id = NEW.occurrence_id AND m.gen_to IS NULL AND m.staging_id IS NULL AND m.sha256 = NEW.segment_sha256))AND CASE WHEN replace(translate(lower(COALESCE(NEW.output::text, '') || ' ' || COALESCE(NEW.receipt::text, '')), 'ς', 'σ'), 'i̇', 'i') LIKE ANY (x.patterns::text[]) THEN EXISTS (SELECT 1 FROM (VALUES (NEW.output), (NEW.receipt)) doc(j),LATERAL (SELECT jsonb_path_query(doc.j, 'strict \$.** ? (@.type() == "string")') #>> '{}' AS tUNION ALL SELECT jsonb_path_query(doc.j, 'strict \$.** ? (@.type() == "object").keyvalue().key') #>> '{}') sWHERE CASE WHEN replace(translate(lower(s.t), 'ς', 'σ'), 'i̇', 'i') LIKE ANY (x.patterns::text[]) THEN EXISTS (SELECT 1 FROM unnest(x.needles::text[]) k(n)- WHERE strpos(' ' || replace(translate(public.gbrain_fact_normalize(s.t), 'ς', 'σ'), 'i̇', 'i') || ' ', k.n) > 0) ELSE false END) ELSE false END) THEN+ WHERE strpos(' ' || replace(translate(gbrain_fact_normalize(s.t), 'ς', 'σ'), 'i̇', 'i') || ' ', k.n) > 0) ELSE false END) ELSE false END) THENRETURN NULL;END IF;RETURN NEW;@@ -1565,31 +1560,6 @@ ENDDROP TRIGGER IF EXISTS page_segment_derivations_refuse_purging ON page_segment_derivations;CREATE TRIGGER page_segment_derivations_refuse_purging BEFORE INSERT OR UPDATE OF output, receipt ON page_segment_derivationsFOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purging_derivation();-CREATE OR REPLACE FUNCTION gbrain_refuse_stored_purging_derivation() RETURNS trigger SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS \$func\$-BEGIN- IF EXISTS (SELECT 1 FROM public.page_segment_derivation_purges x JOIN public.pages p ON p.source_id = x.source_id- WHERE p.id = NEW.page_id AND (NEW.page_id = ANY(x.page_ids::int[]) OR p.deleted_at IS NOT NULL OR NOT EXISTS (SELECT 1 FROM public.page_body_manifest m- WHERE m.page_id = NEW.page_id AND m.occurrence_id = NEW.occurrence_id AND m.gen_to IS NULL AND m.staging_id IS NULL AND m.sha256 = NEW.segment_sha256))- AND CASE WHEN replace(translate(lower(COALESCE(NEW.output::text, '') || ' ' || COALESCE(NEW.receipt::text, '')), 'ς', 'σ'), 'i̇', 'i') LIKE ANY (x.patterns::text[]) THEN EXISTS (SELECT 1 FROM (VALUES (NEW.output), (NEW.receipt)) doc(j),- LATERAL (SELECT jsonb_path_query(doc.j, 'strict \$.** ? (@.type() == "string")') #>> '{}' AS t- UNION ALL SELECT jsonb_path_query(doc.j, 'strict \$.** ? (@.type() == "object").keyvalue().key') #>> '{}') s- WHERE CASE WHEN replace(translate(lower(s.t), 'ς', 'σ'), 'i̇', 'i') LIKE ANY (x.patterns::text[]) THEN EXISTS (SELECT 1 FROM unnest(x.needles::text[]) k(n)- WHERE strpos(' ' || replace(translate(public.gbrain_fact_normalize(s.t), 'ς', 'σ'), 'i̇', 'i') || ' ', k.n) > 0) ELSE false END) ELSE false END) THEN- RAISE EXCEPTION USING ERRCODE = 'P0001',- MESSAGE = 'derivation_purge_pending: a fact purge''s sweep of stored derivation results is still running and this row holds its claim',- DETAIL = json_build_object('table'::text, 'page_segment_derivations'::text)::text;- END IF;- RETURN NULL;-END-\$func\$ LANGUAGE plpgsql;-REVOKE EXECUTE ON FUNCTION gbrain_refuse_stored_purging_derivation() FROM PUBLIC;-DO \$revoke\$ BEGIN- IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'anon') THEN REVOKE EXECUTE ON FUNCTION gbrain_refuse_stored_purging_derivation() FROM anon; END IF;- IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'authenticated') THEN REVOKE EXECUTE ON FUNCTION gbrain_refuse_stored_purging_derivation() FROM authenticated; END IF;-END \$revoke\$;-DROP TRIGGER IF EXISTS page_segment_derivations_refuse_stored_purging ON page_segment_derivations;-CREATE TRIGGER page_segment_derivations_refuse_stored_purging AFTER INSERT OR UPDATE OF output, receipt ON page_segment_derivations- FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_stored_purging_derivation();diff --git a/src/core/schema-embedded.generated.ts b/src/core/schema-embedded.generated.tsindex da812a62d4..421b8d536e 100644--- a/src/core/schema-embedded.generated.ts+++ b/src/core/schema-embedded.generated.ts@@ -2261,7 +2261,7 @@ CREATE TABLE IF NOT EXISTS page_segment_derivation_purge_pages (page_id INTEGER NOT NULL,PRIMARY KEY (request_id, page_id));-CREATE OR REPLACE FUNCTION gbrain_mark_derivation_scope_entry() RETURNS trigger SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS \$func\$+CREATE OR REPLACE FUNCTION gbrain_mark_derivation_scope_entry() RETURNS trigger SET search_path = pg_catalog, public AS \$func\$DECLAREsrc TEXT;page INTEGER;@@ -2273,17 +2273,12 @@ BEGINsrc := OLD.source_id;page := OLD.page_id;END IF;- PERFORM pg_advisory_xact_lock_shared(hashtextextended('gbrain:derivation-scope:'::text || src, 0::bigint));- INSERT INTO public.page_segment_derivation_purge_pages (request_id, page_id)- SELECT x.request_id, page FROM public.page_segment_derivation_purges x WHERE x.source_id = src ON CONFLICT DO NOTHING;+ PERFORM pg_advisory_xact_lock_shared(hashtextextended('gbrain:derivation-scope:' || src, 0));+ INSERT INTO page_segment_derivation_purge_pages (request_id, page_id)+ SELECT x.request_id, page FROM page_segment_derivation_purges x WHERE x.source_id = src ON CONFLICT DO NOTHING;RETURN NULL;END\$func\$ LANGUAGE plpgsql;-REVOKE EXECUTE ON FUNCTION gbrain_mark_derivation_scope_entry() FROM PUBLIC;-DO \$revoke\$ BEGIN- IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'anon') THEN REVOKE EXECUTE ON FUNCTION gbrain_mark_derivation_scope_entry() FROM anon; END IF;- IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'authenticated') THEN REVOKE EXECUTE ON FUNCTION gbrain_mark_derivation_scope_entry() FROM authenticated; END IF;-END \$revoke\$;DROP TRIGGER IF EXISTS page_body_manifest_derivation_scope_retire ON page_body_manifest;CREATE TRIGGER page_body_manifest_derivation_scope_retire AFTER UPDATE OF gen_to ON page_body_manifestFOR EACH ROW WHEN (OLD.gen_to IS NULL AND NEW.gen_to IS NOT NULL AND OLD.staging_id IS NULL) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry();@@ -2296,13 +2291,13 @@ CREATE TRIGGER pages_derivation_scope_delete AFTER UPDATE OF deleted_at ON pagesCREATE OR REPLACE FUNCTION gbrain_refuse_purging_derivation() RETURNS trigger SET search_path = pg_catalog, public AS \$func\$BEGINIF EXISTS (SELECT 1 FROM page_segment_derivation_purges x JOIN pages p ON p.source_id = x.source_id- WHERE p.id = NEW.page_id AND (NEW.page_id = ANY(x.page_ids::int[]) OR p.deleted_at IS NOT NULL OR NOT EXISTS (SELECT 1 FROM public.page_body_manifest m+ WHERE p.id = NEW.page_id AND (NEW.page_id = ANY(x.page_ids::int[]) OR p.deleted_at IS NOT NULL OR NOT EXISTS (SELECT 1 FROM page_body_manifest mWHERE m.page_id = NEW.page_id AND m.occurrence_id = NEW.occurrence_id AND m.gen_to IS NULL AND m.staging_id IS NULL AND m.sha256 = NEW.segment_sha256))AND CASE WHEN replace(translate(lower(COALESCE(NEW.output::text, '') || ' ' || COALESCE(NEW.receipt::text, '')), 'ς', 'σ'), 'i̇', 'i') LIKE ANY (x.patterns::text[]) THEN EXISTS (SELECT 1 FROM (VALUES (NEW.output), (NEW.receipt)) doc(j),LATERAL (SELECT jsonb_path_query(doc.j, 'strict \$.** ? (@.type() == "string")') #>> '{}' AS tUNION ALL SELECT jsonb_path_query(doc.j, 'strict \$.** ? (@.type() == "object").keyvalue().key') #>> '{}') sWHERE CASE WHEN replace(translate(lower(s.t), 'ς', 'σ'), 'i̇', 'i') LIKE ANY (x.patterns::text[]) THEN EXISTS (SELECT 1 FROM unnest(x.needles::text[]) k(n)- WHERE strpos(' ' || replace(translate(public.gbrain_fact_normalize(s.t), 'ς', 'σ'), 'i̇', 'i') || ' ', k.n) > 0) ELSE false END) ELSE false END) THEN+ WHERE strpos(' ' || replace(translate(gbrain_fact_normalize(s.t), 'ς', 'σ'), 'i̇', 'i') || ' ', k.n) > 0) ELSE false END) ELSE false END) THENRETURN NULL;END IF;RETURN NEW;@@ -2311,31 +2306,6 @@ ENDDROP TRIGGER IF EXISTS page_segment_derivations_refuse_purging ON page_segment_derivations;CREATE TRIGGER page_segment_derivations_refuse_purging BEFORE INSERT OR UPDATE OF output, receipt ON page_segment_derivationsFOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purging_derivation();-CREATE OR REPLACE FUNCTION gbrain_refuse_stored_purging_derivation() RETURNS trigger SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS \$func\$-BEGIN- IF EXISTS (SELECT 1 FROM public.page_segment_derivation_purges x JOIN public.pages p ON p.source_id = x.source_id- WHERE p.id = NEW.page_id AND (NEW.page_id = ANY(x.page_ids::int[]) OR p.deleted_at IS NOT NULL OR NOT EXISTS (SELECT 1 FROM public.page_body_manifest m- WHERE m.page_id = NEW.page_id AND m.occurrence_id = NEW.occurrence_id AND m.gen_to IS NULL AND m.staging_id IS NULL AND m.sha256 = NEW.segment_sha256))- AND CASE WHEN replace(translate(lower(COALESCE(NEW.output::text, '') || ' ' || COALESCE(NEW.receipt::text, '')), 'ς', 'σ'), 'i̇', 'i') LIKE ANY (x.patterns::text[]) THEN EXISTS (SELECT 1 FROM (VALUES (NEW.output), (NEW.receipt)) doc(j),- LATERAL (SELECT jsonb_path_query(doc.j, 'strict \$.** ? (@.type() == "string")') #>> '{}' AS t- UNION ALL SELECT jsonb_path_query(doc.j, 'strict \$.** ? (@.type() == "object").keyvalue().key') #>> '{}') s- WHERE CASE WHEN replace(translate(lower(s.t), 'ς', 'σ'), 'i̇', 'i') LIKE ANY (x.patterns::text[]) THEN EXISTS (SELECT 1 FROM unnest(x.needles::text[]) k(n)- WHERE strpos(' ' || replace(translate(public.gbrain_fact_normalize(s.t), 'ς', 'σ'), 'i̇', 'i') || ' ', k.n) > 0) ELSE false END) ELSE false END) THEN- RAISE EXCEPTION USING ERRCODE = 'P0001',- MESSAGE = 'derivation_purge_pending: a fact purge''s sweep of stored derivation results is still running and this row holds its claim',- DETAIL = json_build_object('table'::text, 'page_segment_derivations'::text)::text;- END IF;- RETURN NULL;-END-\$func\$ LANGUAGE plpgsql;-REVOKE EXECUTE ON FUNCTION gbrain_refuse_stored_purging_derivation() FROM PUBLIC;-DO \$revoke\$ BEGIN- IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'anon') THEN REVOKE EXECUTE ON FUNCTION gbrain_refuse_stored_purging_derivation() FROM anon; END IF;- IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'authenticated') THEN REVOKE EXECUTE ON FUNCTION gbrain_refuse_stored_purging_derivation() FROM authenticated; END IF;-END \$revoke\$;-DROP TRIGGER IF EXISTS page_segment_derivations_refuse_stored_purging ON page_segment_derivations;-CREATE TRIGGER page_segment_derivations_refuse_stored_purging AFTER INSERT OR UPDATE OF output, receipt ON page_segment_derivations- FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_stored_purging_derivation();-- END GENERATED from src/core/page-body/schema.ts (PAGE_SEGMENT_DERIVATIONS_SQL)-- BEGIN GENERATED from src/core/page-body/schema.ts (PAGE_BODY_RLS_SQL). Edit that file, then run: bun run build:schema@@ -3639,7 +3609,7 @@ CREATE TABLE IF NOT EXISTS sync_notifier_sources ();-- Last statement: pg_temp ends every gbrain function's pinned search_path (#7632), after any CREATE OR REPLACE above reset it.--- BEGIN GENERATED from src/core/guard-definer.ts (FUNCTION_SEARCH_PATH_HARDENING_SQL). Edit that file, then run: bun run build:schema+-- BEGIN GENERATED from src/core/function-search-path.ts (FUNCTION_SEARCH_PATH_HARDENING_SQL). Edit that file, then run: bun run build:schemaDO \$harden\$DECLARE f RECORD;BEGIN@@ -3652,5 +3622,5 @@ BEGINEXECUTE format('ALTER FUNCTION %s SET search_path = %s, pg_temp', f.sig, f.path);END LOOP;END \$harden\$;--- END GENERATED from src/core/guard-definer.ts (FUNCTION_SEARCH_PATH_HARDENING_SQL)+-- END GENERATED from src/core/function-search-path.ts (FUNCTION_SEARCH_PATH_HARDENING_SQL)`;diff --git a/src/core/schema-migrations/registry.generated.ts b/src/core/schema-migrations/registry.generated.tsindex 76dfaec5bf..192a9c4f1b 100644--- a/src/core/schema-migrations/registry.generated.ts+++ b/src/core/schema-migrations/registry.generated.ts@@ -276,7 +276,7 @@ import { v272 } from './v272-git-canonical-declared.ts';import { v273 } from './v273-segment-derivations.ts';import { v274 } from './v274-pages-withheld-source-path.ts';import { v275 } from './v275-rls-backfill-unguarded-tables.ts';-import { v276 } from './v276-guard-triggers-security-definer.ts';+import { v276 } from './v276-function-search-path-pg-temp.ts';// Array order is historical (see HISTORICAL_ARRAY_ORDER in the generator); the// runner sorts by version before applying.diff --git a/src/core/schema-migrations/v276-function-search-path-pg-temp.ts b/src/core/schema-migrations/v276-function-search-path-pg-temp.tsnew file mode 100644index 0000000000..9a3f738faf--- /dev/null+++ b/src/core/schema-migrations/v276-function-search-path-pg-temp.ts@@ -0,0 +1,49 @@+import type { Migration } from './types.ts';+import type { BrainEngine } from '../engine.ts';+import { migrationStatementTimeoutMs } from '../migration-timeout.ts';+import { isLockTimeoutError } from '../retry-matcher.ts';+import { resolveSchemaLockTimeoutMs, schemaLockBlockedError } from '../postgres-engine/schema-lock-timeout.ts';+import { FUNCTION_SEARCH_PATH_HARDENING_SQL, LEGACY_SEARCH_PATH_SETTINGS } from '../function-search-path.ts';++// Applied by src/core/migrate.ts on the next initSchema(); see docs/ENGINES.md+// ("Canonical schema sources") for when schema.sql or a TS fragment also changes.+//+// #7632: every gbrain function that pins a search_path gets pg_temp appended last (src/core/function-search-path.ts),+// so a temp table or view named like a ledger no longer hides it from a guard. ALTER only, no body changes. ALTER+// FUNCTION needs the owner: a function the migrating role does not own is left as it was and named on stderr, and+// doctor's function_search_path check keeps failing with the SQL to run as its owner. One short transaction with the+// migration's statement and lock timeouts.++/** Appends pg_temp where the role may, then names on stderr and returns every function still without it. */+export async function hardenFunctionSearchPaths(engine: BrainEngine, label: string): Promise<string[]> {+ const lockTimeoutMs = resolveSchemaLockTimeoutMs();+ try {+ await engine.transaction(async tx => {+ if (engine.kind === 'postgres') {+ await tx.executeRaw(`SET LOCAL statement_timeout = '${migrationStatementTimeoutMs()}'`);+ await tx.executeRaw(`SET LOCAL lock_timeout = '${lockTimeoutMs}ms'`);+ }+ await tx.runMigration(276, FUNCTION_SEARCH_PATH_HARDENING_SQL);+ });+ } catch (error) {+ if (isLockTimeoutError(error)) throw schemaLockBlockedError({ step: `${label} search_path`, timeoutMs: lockTimeoutMs, sessions: null, sampledDuringWait: false });+ throw error;+ }+ const left = (await engine.executeRaw<{ sig: string }>(+ `SELECT p.oid::regprocedure::text AS sig FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace+ WHERE n.nspname = 'public' AND p.proconfig && $1::text[] ORDER BY 1`, [[...LEGACY_SEARCH_PATH_SETTINGS]])).map(r => r.sig);+ if (left.length > 0) {+ process.stderr.write(` ${label}: ${left.length} function(s) left without pg_temp on their search_path (${left.join(', ')}): `+ + 'ALTER FUNCTION needs the owner. Run gbrain doctor for the SQL to run as that role.\n');+ }+ return left;+}++export const v276: Migration = {+ version: 276,+ name: 'function_search_path_pg_temp',+ idempotent: true,+ transaction: false,+ sql: '',+ handler: async engine => { await hardenFunctionSearchPaths(engine, 'v276'); },+};diff --git a/src/core/schema-migrations/v276-guard-triggers-security-definer.ts b/src/core/schema-migrations/v276-guard-triggers-security-definer.tsdeleted file mode 100644index 1f5a7487ec..0000000000--- a/src/core/schema-migrations/v276-guard-triggers-security-definer.ts+++ /dev/null@@ -1,105 +0,0 @@-import type { Migration } from './types.ts';-import type { BrainEngine } from '../engine.ts';-import { migrationStatementTimeoutMs } from '../migration-timeout.ts';-import { isLockTimeoutError } from '../retry-matcher.ts';-import { resolveSchemaLockTimeoutMs, schemaLockBlockedError } from '../postgres-engine/schema-lock-timeout.ts';-import {- DEFINER_FUNCTION_SQL, DEFINER_GUARDS, DEFINER_TRIGGERS, FUNCTION_SEARCH_PATH_HARDENING_SQL, LEGACY_SEARCH_PATH_SETTINGS,-} from '../guard-definer.ts';-import { DERIVATION_SCOPE_ENTRY_FUNCTION_SQL, DERIVATION_STORED_GUARD_FUNCTION_SQL, DERIVATION_STORED_GUARD_TRIGGER_SQL } from '../page-body/schema.ts';--// Applied by src/core/migrate.ts on the next initSchema(); see docs/ENGINES.md-// ("Canonical schema sources") for when schema.sql or a TS fragment also changes.-//-// #7632: the purge and withdrawal guards read their ledgers as their owner (SECURITY DEFINER), so a write role without-// a policy on a ledger no longer slips a purged claim, page, take or derivation, or a withdrawn fact, past them. The-// rest of the change keeps that from widening anyone's reach (src/core/guard-definer.ts): each definer is rewritten with-// search_path = pg_catalog, pg_temp and every gbrain name schema-qualified, pg_temp is appended to every other gbrain-// function's path, EXECUTE is revoked from PUBLIC/anon/authenticated, and every definer that refuses fires AFTER ROW or-// AFTER STATEMENT, so a definer never answers a role RLS refuses. The guards that silently correct a row stay master's-// invokers. Function and trigger DDL needs the owner: a function or table the role does not own is skipped and named on-// stderr, as v275 does, and doctor's guard_functions check keeps failing with the fix until it is done. Each function-// and each table is its own short transaction with the migration's statement and lock timeouts.--/** Every definer guard's CREATE OR REPLACE (body, pinned path, revoke), by function. */-export const GUARD_FUNCTION_SQL: Readonly<Record<string, string>> = {- ...DEFINER_FUNCTION_SQL,- gbrain_mark_derivation_scope_entry: DERIVATION_SCOPE_ENTRY_FUNCTION_SQL,- gbrain_refuse_stored_purging_derivation: DERIVATION_STORED_GUARD_FUNCTION_SQL,-};--/** The definer guards' triggers, each AFTER; its table step creates the function and the trigger together. */-export const GUARD_TRIGGERS: ReadonlyArray<{ table: string; trigger: string; fn: string; sql: string }> = [- ...DEFINER_TRIGGERS,- { table: 'page_segment_derivations', trigger: 'page_segment_derivations_refuse_stored_purging', fn: 'gbrain_refuse_stored_purging_derivation', sql: DERIVATION_STORED_GUARD_TRIGGER_SQL },-];--async function inShortTransaction(engine: BrainEngine, step: string, sql: string): Promise<void> {- const lockTimeoutMs = resolveSchemaLockTimeoutMs();- try {- await engine.transaction(async tx => {- if (engine.kind === 'postgres') {- await tx.executeRaw(`SET LOCAL statement_timeout = '${migrationStatementTimeoutMs()}'`);- await tx.executeRaw(`SET LOCAL lock_timeout = '${lockTimeoutMs}ms'`);- }- await tx.runMigration(276, sql);- });- } catch (error) {- if (isLockTimeoutError(error)) throw schemaLockBlockedError({ step, timeoutMs: lockTimeoutMs, sessions: null, sampledDuringWait: false });- throw error;- }-}--/**- * For each guard trigger on a table the role owns, creates its definer function and moves or creates the trigger in- * one transaction; then rewrites every other definer guard the role owns, unless its trigger still fires BEFORE ROW- * (the role could not move it), so a definer never answers before RLS; then appends pg_temp to every gbrain function's- * search_path. Names on stderr what it could not change (a guard whose table step was skipped may be absent) and- * returns those names.- */-export async function hardenGuards(engine: BrainEngine, label: string): Promise<string[]> {- const skipped: string[] = [];- const done = new Set<string>();- const tables = await engine.executeRaw<{ name: string; owned: boolean | null }>(- `SELECT t.name, pg_has_role(current_user, c.relowner, 'USAGE') AS owned- FROM unnest($1::text[]) AS t(name) JOIN pg_class c ON c.oid = to_regclass(t.name)`,- [[...new Set(GUARD_TRIGGERS.map(t => t.table))]]);- for (const t of GUARD_TRIGGERS) {- const table = tables.find(row => row.name === t.table);- if (!table) continue;- if (!table.owned) { skipped.push(`${t.trigger} on ${t.table}`); continue; }- await inShortTransaction(engine, `${label} on ${t.table}`, `${GUARD_FUNCTION_SQL[t.fn]}\n${t.sql}`);- done.add(t.fn);- }- const exposed = new Set((await engine.executeRaw<{ fn: string }>(- `SELECT DISTINCT p.proname AS fn FROM pg_trigger t JOIN pg_proc p ON p.oid = t.tgfoid- WHERE NOT t.tgisinternal AND p.proname = ANY($1::text[]) AND (t.tgtype & 2) <> 0`,- [GUARD_TRIGGERS.map(t => t.fn)])).map(r => r.fn));- const functions = await engine.executeRaw<{ fn: string; owned: boolean | null }>(- `SELECT f.fn, pg_has_role(current_user, p.proowner, 'USAGE') AS owned- FROM unnest($1::text[]) AS f(fn) LEFT JOIN pg_proc p ON p.oid = to_regprocedure(f.fn || '()') ORDER BY f.fn`,- [DEFINER_GUARDS.map(g => g.fn).filter(fn => !done.has(fn))]);- for (const { fn, owned } of functions) {- if (owned && !exposed.has(fn)) await inShortTransaction(engine, `${label} on ${fn}()`, GUARD_FUNCTION_SQL[fn]!);- else skipped.push(`${fn}()`);- }- await inShortTransaction(engine, `${label} search_path`, FUNCTION_SEARCH_PATH_HARDENING_SQL);- const unhardened = await engine.executeRaw<{ sig: string }>(- `SELECT p.oid::regprocedure::text AS sig FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace- WHERE n.nspname = 'public' AND p.proconfig && $1::text[] ORDER BY 1`, [[...LEGACY_SEARCH_PATH_SETTINGS]]);- skipped.push(...unhardened.map(r => r.sig));- if (skipped.length > 0) {- process.stderr.write(` ${label}: ${skipped.length} function(s) or trigger(s) left as they were (${skipped.join(', ')}): `- + 'the role must own them, and a guard its trigger\'s table. Run gbrain doctor for the fix.\n');- }- return skipped;-}--export const v276: Migration = {- version: 276,- name: 'guard_triggers_security_definer',- idempotent: true,- transaction: false,- sql: '',- handler: async engine => { await hardenGuards(engine, 'v276'); },-};diff --git a/src/schema.sql b/src/schema.sqlindex f106f2394f..73b16820ab 100644--- a/src/schema.sql+++ b/src/schema.sql@@ -2257,7 +2257,7 @@ CREATE TABLE IF NOT EXISTS page_segment_derivation_purge_pages (page_id INTEGER NOT NULL,PRIMARY KEY (request_id, page_id));-CREATE OR REPLACE FUNCTION gbrain_mark_derivation_scope_entry() RETURNS trigger SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $func$+CREATE OR REPLACE FUNCTION gbrain_mark_derivation_scope_entry() RETURNS trigger SET search_path = pg_catalog, public AS $func$DECLAREsrc TEXT;page INTEGER;@@ -2269,17 +2269,12 @@ BEGINsrc := OLD.source_id;page := OLD.page_id;END IF;- PERFORM pg_advisory_xact_lock_shared(hashtextextended('gbrain:derivation-scope:'::text || src, 0::bigint));- INSERT INTO public.page_segment_derivation_purge_pages (request_id, page_id)- SELECT x.request_id, page FROM public.page_segment_derivation_purges x WHERE x.source_id = src ON CONFLICT DO NOTHING;+ PERFORM pg_advisory_xact_lock_shared(hashtextextended('gbrain:derivation-scope:' || src, 0));+ INSERT INTO page_segment_derivation_purge_pages (request_id, page_id)+ SELECT x.request_id, page FROM page_segment_derivation_purges x WHERE x.source_id = src ON CONFLICT DO NOTHING;RETURN NULL;END$func$ LANGUAGE plpgsql;-REVOKE EXECUTE ON FUNCTION gbrain_mark_derivation_scope_entry() FROM PUBLIC;-DO $revoke$ BEGIN- IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'anon') THEN REVOKE EXECUTE ON FUNCTION gbrain_mark_derivation_scope_entry() FROM anon; END IF;- IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'authenticated') THEN REVOKE EXECUTE ON FUNCTION gbrain_mark_derivation_scope_entry() FROM authenticated; END IF;-END $revoke$;DROP TRIGGER IF EXISTS page_body_manifest_derivation_scope_retire ON page_body_manifest;CREATE TRIGGER page_body_manifest_derivation_scope_retire AFTER UPDATE OF gen_to ON page_body_manifestFOR EACH ROW WHEN (OLD.gen_to IS NULL AND NEW.gen_to IS NOT NULL AND OLD.staging_id IS NULL) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry();@@ -2292,13 +2287,13 @@ CREATE TRIGGER pages_derivation_scope_delete AFTER UPDATE OF deleted_at ON pagesCREATE OR REPLACE FUNCTION gbrain_refuse_purging_derivation() RETURNS trigger SET search_path = pg_catalog, public AS $func$BEGINIF EXISTS (SELECT 1 FROM page_segment_derivation_purges x JOIN pages p ON p.source_id = x.source_id- WHERE p.id = NEW.page_id AND (NEW.page_id = ANY(x.page_ids::int[]) OR p.deleted_at IS NOT NULL OR NOT EXISTS (SELECT 1 FROM public.page_body_manifest m+ WHERE p.id = NEW.page_id AND (NEW.page_id = ANY(x.page_ids::int[]) OR p.deleted_at IS NOT NULL OR NOT EXISTS (SELECT 1 FROM page_body_manifest mWHERE m.page_id = NEW.page_id AND m.occurrence_id = NEW.occurrence_id AND m.gen_to IS NULL AND m.staging_id IS NULL AND m.sha256 = NEW.segment_sha256))AND CASE WHEN replace(translate(lower(COALESCE(NEW.output::text, '') || ' ' || COALESCE(NEW.receipt::text, '')), 'ς', 'σ'), 'i̇', 'i') LIKE ANY (x.patterns::text[]) THEN EXISTS (SELECT 1 FROM (VALUES (NEW.output), (NEW.receipt)) doc(j),LATERAL (SELECT jsonb_path_query(doc.j, 'strict $.** ? (@.type() == "string")') #>> '{}' AS tUNION ALL SELECT jsonb_path_query(doc.j, 'strict $.** ? (@.type() == "object").keyvalue().key') #>> '{}') sWHERE CASE WHEN replace(translate(lower(s.t), 'ς', 'σ'), 'i̇', 'i') LIKE ANY (x.patterns::text[]) THEN EXISTS (SELECT 1 FROM unnest(x.needles::text[]) k(n)- WHERE strpos(' ' || replace(translate(public.gbrain_fact_normalize(s.t), 'ς', 'σ'), 'i̇', 'i') || ' ', k.n) > 0) ELSE false END) ELSE false END) THEN+ WHERE strpos(' ' || replace(translate(gbrain_fact_normalize(s.t), 'ς', 'σ'), 'i̇', 'i') || ' ', k.n) > 0) ELSE false END) ELSE false END) THENRETURN NULL;END IF;RETURN NEW;@@ -2307,31 +2302,6 @@ $func$ LANGUAGE plpgsql;DROP TRIGGER IF EXISTS page_segment_derivations_refuse_purging ON page_segment_derivations;CREATE TRIGGER page_segment_derivations_refuse_purging BEFORE INSERT OR UPDATE OF output, receipt ON page_segment_derivationsFOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purging_derivation();-CREATE OR REPLACE FUNCTION gbrain_refuse_stored_purging_derivation() RETURNS trigger SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $func$-BEGIN- IF EXISTS (SELECT 1 FROM public.page_segment_derivation_purges x JOIN public.pages p ON p.source_id = x.source_id- WHERE p.id = NEW.page_id AND (NEW.page_id = ANY(x.page_ids::int[]) OR p.deleted_at IS NOT NULL OR NOT EXISTS (SELECT 1 FROM public.page_body_manifest m- WHERE m.page_id = NEW.page_id AND m.occurrence_id = NEW.occurrence_id AND m.gen_to IS NULL AND m.staging_id IS NULL AND m.sha256 = NEW.segment_sha256))- AND CASE WHEN replace(translate(lower(COALESCE(NEW.output::text, '') || ' ' || COALESCE(NEW.receipt::text, '')), 'ς', 'σ'), 'i̇', 'i') LIKE ANY (x.patterns::text[]) THEN EXISTS (SELECT 1 FROM (VALUES (NEW.output), (NEW.receipt)) doc(j),- LATERAL (SELECT jsonb_path_query(doc.j, 'strict $.** ? (@.type() == "string")') #>> '{}' AS t- UNION ALL SELECT jsonb_path_query(doc.j, 'strict $.** ? (@.type() == "object").keyvalue().key') #>> '{}') s- WHERE CASE WHEN replace(translate(lower(s.t), 'ς', 'σ'), 'i̇', 'i') LIKE ANY (x.patterns::text[]) THEN EXISTS (SELECT 1 FROM unnest(x.needles::text[]) k(n)- WHERE strpos(' ' || replace(translate(public.gbrain_fact_normalize(s.t), 'ς', 'σ'), 'i̇', 'i') || ' ', k.n) > 0) ELSE false END) ELSE false END) THEN- RAISE EXCEPTION USING ERRCODE = 'P0001',- MESSAGE = 'derivation_purge_pending: a fact purge''s sweep of stored derivation results is still running and this row holds its claim',- DETAIL = json_build_object('table'::text, 'page_segment_derivations'::text)::text;- END IF;- RETURN NULL;-END-$func$ LANGUAGE plpgsql;-REVOKE EXECUTE ON FUNCTION gbrain_refuse_stored_purging_derivation() FROM PUBLIC;-DO $revoke$ BEGIN- IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'anon') THEN REVOKE EXECUTE ON FUNCTION gbrain_refuse_stored_purging_derivation() FROM anon; END IF;- IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'authenticated') THEN REVOKE EXECUTE ON FUNCTION gbrain_refuse_stored_purging_derivation() FROM authenticated; END IF;-END $revoke$;-DROP TRIGGER IF EXISTS page_segment_derivations_refuse_stored_purging ON page_segment_derivations;-CREATE TRIGGER page_segment_derivations_refuse_stored_purging AFTER INSERT OR UPDATE OF output, receipt ON page_segment_derivations- FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_stored_purging_derivation();-- END GENERATED from src/core/page-body/schema.ts (PAGE_SEGMENT_DERIVATIONS_SQL)-- BEGIN GENERATED from src/core/page-body/schema.ts (PAGE_BODY_RLS_SQL). Edit that file, then run: bun run build:schema@@ -3635,7 +3605,7 @@ CREATE TABLE IF NOT EXISTS sync_notifier_sources ();-- Last statement: pg_temp ends every gbrain function's pinned search_path (#7632), after any CREATE OR REPLACE above reset it.--- BEGIN GENERATED from src/core/guard-definer.ts (FUNCTION_SEARCH_PATH_HARDENING_SQL). Edit that file, then run: bun run build:schema+-- BEGIN GENERATED from src/core/function-search-path.ts (FUNCTION_SEARCH_PATH_HARDENING_SQL). Edit that file, then run: bun run build:schemaDO $harden$DECLARE f RECORD;BEGIN@@ -3648,4 +3618,4 @@ BEGINEXECUTE format('ALTER FUNCTION %s SET search_path = %s, pg_temp', f.sig, f.path);END LOOP;END $harden$;--- END GENERATED from src/core/guard-definer.ts (FUNCTION_SEARCH_PATH_HARDENING_SQL)+-- END GENERATED from src/core/function-search-path.ts (FUNCTION_SEARCH_PATH_HARDENING_SQL)diff --git a/test/doctor-function-search-path.test.ts b/test/doctor-function-search-path.test.tsnew file mode 100644index 0000000000..2316cd44e2--- /dev/null+++ b/test/doctor-function-search-path.test.ts@@ -0,0 +1,39 @@+/**+ * function_search_path doctor check (#7632): names every gbrain function whose pinned search_path lacks a trailing+ * pg_temp, with the ALTER FUNCTION that fixes it; the fix changes no owner, so the next boot still succeeds. The Postgres+ * non-owner path is in test/e2e/function-search-path-postgres.test.ts (case 5).+ */+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';+import { PGLiteEngine } from '../src/core/pglite-engine.ts';+import { functionSearchPathProblems } from '../src/commands/doctor/checks/function-search-path.ts';++describe('function_search_path doctor check (#7632)', () => {+ let engine: PGLiteEngine;+ beforeAll(async () => {+ engine = new PGLiteEngine();+ await engine.connect({});+ await engine.initSchema();+ }, 120_000);+ afterAll(async () => { await engine?.disconnect(); });++ test('a fresh install has no problem', async () => {+ expect(await functionSearchPathProblems(engine)).toEqual({ functions: [], fix: [] });+ });++ test('each function without pg_temp is named, running the printed fix clears it, and a boot after the fix still succeeds', async () => {+ await engine.runMigration(0, `ALTER FUNCTION gbrain_refuse_purged_page() SET search_path = pg_catalog, public;+ ALTER FUNCTION gbrain_fts_input(text) SET search_path = pg_catalog;`);+ const { functions, fix } = await functionSearchPathProblems(engine);+ expect({ functions, fix }).toEqual({+ functions: ['gbrain_fts_input(text)', 'gbrain_refuse_purged_page()'],+ fix: [+ 'ALTER FUNCTION gbrain_fts_input(text) SET search_path = pg_catalog, pg_temp;',+ 'ALTER FUNCTION gbrain_refuse_purged_page() SET search_path = pg_catalog, public, pg_temp;',+ ],+ });+ await engine.runMigration(0, fix.join('\n'));+ expect(await functionSearchPathProblems(engine)).toEqual({ functions: [], fix: [] });+ await engine.initSchema();+ expect(await functionSearchPathProblems(engine)).toEqual({ functions: [], fix: [] });+ }, 120_000);+});diff --git a/test/doctor-guard-functions.test.ts b/test/doctor-guard-functions.test.tsdeleted file mode 100644index ce9804e51a..0000000000--- a/test/doctor-guard-functions.test.ts+++ /dev/null@@ -1,102 +0,0 @@-/**- * guard_functions doctor check (#7632): guardFunctionProblems names each guard drift with SQL that clears it. The- * Postgres non-owner path is in test/e2e/guard-definer-postgres.test.ts (case 11).- */-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';-import { PGLiteEngine } from '../src/core/pglite-engine.ts';-import { guardFunctionProblems } from '../src/commands/doctor/checks/guard-functions.ts';-import { derivationScopeLockSql } from '../src/core/page-body/schema.ts';--describe('guard_functions doctor check (#7632)', () => {- let engine: PGLiteEngine;- beforeAll(async () => {- engine = new PGLiteEngine();- await engine.connect({});- await engine.initSchema();- }, 120_000);- afterAll(async () => { await engine?.disconnect(); });-- test('a fresh install has no problem', async () => {- expect(await guardFunctionProblems(engine)).toEqual({ problems: [], fix: [] });- });-- test('each drift is named, and running the printed fix clears every one', async () => {- await engine.runMigration(0, `ALTER FUNCTION gbrain_refuse_purged_page() SECURITY INVOKER SET search_path = pg_catalog, public;- GRANT EXECUTE ON FUNCTION gbrain_refuse_purged_take() TO PUBLIC;- DROP TRIGGER pages_refuse_purged ON pages;- CREATE TRIGGER pages_refuse_purged BEFORE INSERT OR UPDATE ON pages FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_page();- DROP TRIGGER page_segment_derivations_refuse_stored_purging ON page_segment_derivations;- ALTER FUNCTION gbrain_try_jsonb(text) SET search_path = pg_catalog, public;`);- const { problems, fix } = await guardFunctionProblems(engine);- expect(problems).toEqual([- 'gbrain_refuse_purged_page() is not SECURITY DEFINER with search_path pg_catalog, pg_temp',- 'gbrain_refuse_purged_take() is executable by PUBLIC',- 'pages_refuse_purged on pages still fires BEFORE ROW',- 'page_segment_derivations has no page_segment_derivations_refuse_stored_purging AFTER check',- '1 function(s) pin search_path without pg_temp last (gbrain_try_jsonb(text))',- ]);- await engine.runMigration(0, fix.join('\n'));- expect(await guardFunctionProblems(engine)).toEqual({ problems: [], fix: [] });- });-- // Generated by gstack /ship coverage audit (#7642).- // Value: protects=doctor names a stored-derivation check that fires BEFORE ROW (a definer raising before RLS) and its fix- // moves it AFTER ROW; fails_when=the trigger probe accepts page_segment_derivations_refuse_stored_purging at any timing;- // why_new=the drift test above only drops the trigger; seam=none; no_claim=the RLS oracle itself (PGLite has one role;- // e2e case 8 covers it)- test('a stored-derivation check that fires BEFORE ROW is named, and the fix moves it AFTER ROW', async () => {- await engine.runMigration(0, `DROP TRIGGER page_segment_derivations_refuse_stored_purging ON page_segment_derivations;- CREATE TRIGGER page_segment_derivations_refuse_stored_purging BEFORE INSERT OR UPDATE OF output, receipt ON page_segment_derivations- FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_stored_purging_derivation();`);- const { problems, fix } = await guardFunctionProblems(engine);- expect(problems).toEqual(['page_segment_derivations_refuse_stored_purging on page_segment_derivations still fires BEFORE ROW']);- await engine.runMigration(0, fix.join('\n'));- expect(await guardFunctionProblems(engine)).toEqual({ problems: [], fix: [] });- });-- // An older gbrain booting against an upgraded brain replays its schema blob, whose CREATE OR REPLACE of the scope-entry- // function (as on master before #7632) makes it an invoker again: doctor names it and its fix restores the definer.- test('a scope-entry function an older gbrain re-created as an invoker is named, and the fix restores the definer', async () => {- await engine.runMigration(0, `CREATE OR REPLACE FUNCTION gbrain_mark_derivation_scope_entry() RETURNS trigger SET search_path = pg_catalog, public AS $func$-DECLARE- src TEXT;- page INTEGER;-BEGIN- IF TG_TABLE_NAME = 'pages' THEN- src := NEW.source_id;- page := NEW.id;- ELSE- src := OLD.source_id;- page := OLD.page_id;- END IF;- PERFORM pg_advisory_xact_lock_shared(${derivationScopeLockSql('src')});- INSERT INTO page_segment_derivation_purge_pages (request_id, page_id)- SELECT x.request_id, page FROM page_segment_derivation_purges x WHERE x.source_id = src ON CONFLICT DO NOTHING;- RETURN NULL;-END-$func$ LANGUAGE plpgsql;`);- const { problems, fix } = await guardFunctionProblems(engine);- expect(problems).toEqual(['gbrain_mark_derivation_scope_entry() is not SECURITY DEFINER with search_path pg_catalog, pg_temp']);- await engine.runMigration(0, fix.join('\n'));- expect(await guardFunctionProblems(engine)).toEqual({ problems: [], fix: [] });- const [fn] = await engine.executeRaw<{ secdef: boolean; config: string[] }>(- `SELECT prosecdef AS secdef, proconfig AS config FROM pg_proc WHERE oid = 'gbrain_mark_derivation_scope_entry()'::regprocedure`);- expect(fn).toEqual({ secdef: true, config: ['search_path=pg_catalog, pg_temp'] });- });-- // Generated by gstack /ship coverage audit (#7642).- // Value: protects=doctor asks for the stored-derivation check only where page_segment_derivations exists, so its fix never- // targets a missing table; fails_when=the to_regclass presence probe is dropped; why_new=every other doctor test has the- // table; seam=none; no_claim=a real pre-v273 Postgres brain (a dropped table on PGLite stands in)- test('a brain without page_segment_derivations is not asked for its check', async () => {- const bare = new PGLiteEngine();- try {- await bare.connect({});- await bare.initSchema();- await bare.runMigration(0, 'DROP TABLE page_segment_derivations CASCADE');- expect(await guardFunctionProblems(bare)).toEqual({ problems: [], fix: [] });- } finally {- await bare.disconnect();- }- }, 120_000);-});diff --git a/test/e2e/function-search-path-postgres.test.ts b/test/e2e/function-search-path-postgres.test.tsnew file mode 100644index 0000000000..a0366c101c--- /dev/null+++ b/test/e2e/function-search-path-postgres.test.ts@@ -0,0 +1,321 @@+/**+ * Every gbrain function that pins a search_path ends it with pg_temp, so a temp table or view named like a purge or+ * withdrawal ledger no longer hides it from the guard that reads it (#7632, src/core/function-search-path.ts).+ *+ * Before, the guards pinned `pg_catalog, public`, which leaves the caller's temporary schema first in the relation+ * search: any session could create an empty temp table named fact_purges (or take_purges, page_purges, fact_withdrawals,+ * page_segment_derivation_purges) and store a purged claim, take, page or derivation again, or save a withdrawn fact+ * active, as the owner or as a non-owner writer. The guards themselves are as on master (SECURITY INVOKER, same bodies,+ * same timing); a writer with no policy on a ledger still reads it empty under its own RLS (#7659), which this file does+ * not cover: its writer has policies on every table.+ * Run: DATABASE_URL=... bun test test/e2e/function-search-path-postgres.test.ts+ */+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';+import { randomUUID } from 'node:crypto';+import postgres from '#postgres';+import { assertSafeE2eDatabaseUrl } from '../helpers/db-guard.ts';+import { PostgresEngine } from '../../src/core/postgres-engine.ts';+import { LATEST_VERSION, runMigrations } from '../../src/core/migrate.ts';+import { derivationNeedles } from '../../src/core/page-body/segment-derive.ts';++const DATABASE_URL = process.env.DATABASE_URL;+const describeE2E = DATABASE_URL ? describe : describe.skip;++type Sql = ReturnType<typeof postgres>;+type Outcome = { rows: Array<Record<string, unknown>> } | { code: string; message: string };++const PURGED_CLAIM = 'alice-example joined acme-example as cto';+const WITHDRAWN_CLAIM = 'alice-example lives in city-a';+const PURGED_TAKE = 'acme-example will double revenue';+const PURGED_HASH = 'deadbeefcafe00000000000000000001';+const SHA = `decode(repeat('ab', 32), 'hex')`;+const SHADOWED = ['fact_purges', 'fact_withdrawals', 'take_purges', 'page_purges', 'page_segment_derivation_purges'];+const GUARD_TRIGGERS = ['facts_guard_inserted', 'facts_preserve_withdrawal', 'facts_refuse_purged', 'page_segment_derivations_refuse_purging',+ 'pages_refuse_purged', 'takes_refuse_purged'];++const suffix = randomUUID().replaceAll('-', '').slice(0, 12);+const WRITER = `gbrain_test_path_writer_${suffix}`;+const scratch: string[] = [];+const createdRoles: string[] = [];+let admin: Sql | null = null;++function urlFor(name: string): string {+ const url = new URL(DATABASE_URL!);+ url.pathname = `/${name}`;+ return url.toString();+}++async function freshBrain(): Promise<{ url: string; conn: Sql }> {+ assertSafeE2eDatabaseUrl(DATABASE_URL!);+ const name = `gbrain_test_path_${randomUUID().replaceAll('-', '')}`;+ await admin!.unsafe(`CREATE DATABASE ${name}`);+ scratch.push(name);+ const url = urlFor(name);+ const conn = postgres(url, { max: 1, prepare: false, onnotice: () => {} });+ const engine = new PostgresEngine();+ await engine.connect({ database_url: url });+ try { await engine.initSchema(); } finally { await engine.disconnect(); }+ return { url, conn };+}++/** Runs `fn` as `role` in one transaction that is rolled back; each `run` is its own savepoint. */+async function as<T>(conn: Sql, role: string, fn: (run: (sql: string, params?: unknown[]) => Promise<Outcome>) => Promise<T>): Promise<T> {+ const session = await conn.reserve();+ try {+ await session.unsafe('BEGIN');+ await session.unsafe(`SET LOCAL ROLE ${role}`);+ return await fn(async (sql, params) => {+ await session.unsafe('SAVEPOINT attempt');+ try {+ const rows = await session.unsafe(sql, params as never[]);+ await session.unsafe('RELEASE SAVEPOINT attempt');+ return { rows: [...rows] as Array<Record<string, unknown>> };+ } catch (error) {+ await session.unsafe('ROLLBACK TO SAVEPOINT attempt');+ const e = error as { code?: string; message?: string };+ return { code: String(e.code), message: String(e.message) };+ }+ });+ } finally {+ await session.unsafe('ROLLBACK').catch(() => {});+ session.release();+ }+}++const rowsOf = (o: Outcome) => ('rows' in o ? o.rows : (() => { throw new Error(`expected rows, got ${o.code}: ${o.message}`); })());+const outcome = (o: Outcome) => ('code' in o ? o.message.split(':')[0] : `stored ${o.rows.length}`);++async function capturingStderr<T>(fn: () => Promise<T>): Promise<{ value: T; stderr: string }> {+ const write = process.stderr.write.bind(process.stderr);+ let stderr = '';+ process.stderr.write = ((chunk: string | Uint8Array) => { stderr += String(chunk); return true; }) as typeof process.stderr.write;+ try { return { value: await fn(), stderr }; } finally { process.stderr.write = write; }+}++/** SECURITY DEFINER functions, guard trigger timing and every pinned search_path in public. */+async function catalog(c: Sql) {+ const definers = await c.unsafe<Array<{ fn: string }>>(+ `SELECT p.oid::regprocedure::text AS fn FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname = 'public' AND p.prosecdef ORDER BY 1`);+ const triggers = await c.unsafe<Array<{ trigger: string; timing: string }>>(+ `SELECT tgname AS trigger, CASE WHEN (tgtype & 2) <> 0 THEN 'BEFORE' ELSE 'AFTER' END AS timing FROM pg_trigger+ WHERE NOT tgisinternal AND tgname = ANY($1::text[]) ORDER BY 1`, [GUARD_TRIGGERS]);+ const paths = await c.unsafe<Array<{ sig: string; setting: string }>>(+ `SELECT p.oid::regprocedure::text AS sig, s.setting FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace+ CROSS JOIN LATERAL unnest(p.proconfig) AS s(setting) WHERE n.nspname = 'public' AND s.setting LIKE 'search_path=%' ORDER BY 1`);+ return {+ definers: definers.map(d => d.fn),+ triggers: triggers.map(t => ({ trigger: t.trigger, timing: t.timing })),+ pinned: paths.length,+ withoutTemp: paths.filter(p => !p.setting.endsWith(', pg_temp')).map(p => p.sig),+ };+}++/** Puts a brain back in the shape every brain had before #7632 (no pg_temp on any pinned path), at the version before. */+async function rewind(c: Sql): Promise<void> {+ await c.unsafe(`DO $$ DECLARE f RECORD; BEGIN+ FOR f IN SELECT p.oid::regprocedure AS sig, substr(s.setting, 13) AS path FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace+ CROSS JOIN LATERAL unnest(p.proconfig) AS s(setting) WHERE n.nspname = 'public' AND s.setting LIKE 'search_path=%, pg_temp' LOOP+ EXECUTE format('ALTER FUNCTION %s SET search_path = %s', f.sig, left(f.path, -9));+ END LOOP; END $$;+ UPDATE config SET value = '${LATEST_VERSION - 1}' WHERE key = 'version';`);+}++describeE2E('a temp table or view named like a ledger hides nothing from the guards (#7632)', () => {+ let conn: Sql;+ let url: string;+ let owner = '';+ const ids: Record<string, number> = {};++ beforeAll(async () => {+ assertSafeE2eDatabaseUrl(DATABASE_URL!);+ admin = postgres(DATABASE_URL!, { max: 1, prepare: false, onnotice: () => {} });+ await admin.unsafe(`CREATE ROLE ${WRITER} NOLOGIN NOSUPERUSER NOBYPASSRLS`);+ createdRoles.push(WRITER);+ ({ url, conn } = await freshBrain());+ [{ owner }] = await conn.unsafe<Array<{ owner: string }>>('SELECT current_user AS owner');+ // A non-owner writer with a policy on every RLS table, ledgers included: the guards refuse it exactly as the owner.+ await conn.unsafe(`GRANT USAGE ON SCHEMA public TO ${WRITER};+ GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO ${WRITER};+ GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO ${WRITER};+ DO $$ DECLARE t RECORD; BEGIN+ FOR t IN SELECT c.oid::regclass AS rel FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace+ WHERE n.nspname = 'public' AND c.relkind IN ('r', 'p') AND c.relrowsecurity LOOP+ EXECUTE format('CREATE POLICY gbrain_test_writer ON %s TO ${WRITER} USING (true) WITH CHECK (true)', t.rel);+ END LOOP; END $$`);+ for (const [key, slug] of [['takes', 'people/alice-example'], ['derived', 'notes/derivation-example']]) {+ const [row] = await conn.unsafe<Array<{ id: number }>>(`INSERT INTO pages (slug, type, title, compiled_truth) VALUES ($1, 'note', $1, 'x') RETURNING id`, [slug]);+ ids[key] = row!.id;+ }+ await conn.unsafe(`INSERT INTO fact_purges (source_id, visibility, subject, fact_hash) VALUES ('default', 'private', '*', gbrain_fact_fingerprint($1))`, [PURGED_CLAIM]);+ await conn.unsafe(`INSERT INTO fact_withdrawals (source_id, visibility, subject, fact_hash) VALUES ('default', 'private', '*', gbrain_fact_fingerprint($1))`, [WITHDRAWN_CLAIM]);+ await conn.unsafe(`INSERT INTO page_purges (source_id, content_hash, slug) VALUES ('default', $1, 'notes/purged-example')`, [PURGED_HASH]);+ await conn.unsafe(`INSERT INTO take_purges (source_id, subject, claim_hash) VALUES ('default', '*', gbrain_fact_fingerprint($1))`, [PURGED_TAKE]);+ const { needles, patterns } = await derivationNeedles({ executeRaw: (sql: string, params?: unknown[]) => conn.unsafe(sql, params as never[]) } as never, [PURGED_CLAIM]);+ await conn.unsafe(`INSERT INTO page_segment_derivation_purges (request_id, source_id, needles, patterns, page_ids) VALUES ($1::uuid, 'default', $2::text[], $3::text[], $4::int[])`,+ [randomUUID(), needles, patterns, [ids.derived]]);+ }, 300_000);++ afterAll(async () => {+ await conn?.end();+ if (admin) {+ for (const name of scratch) await admin.unsafe(`DROP DATABASE IF EXISTS ${name} WITH (FORCE)`);+ for (const role of createdRoles) await admin.unsafe(`DROP ROLE IF EXISTS ${role}`).catch(() => {});+ await admin.end();+ }+ });++ /** Each guarded write the ledgers should stop, and what became of it. */+ async function guardedWrites(run: (sql: string, params?: unknown[]) => Promise<Outcome>) {+ const fact = outcome(await run(`INSERT INTO facts (fact, source) VALUES ($1, 'probe') RETURNING id`, [PURGED_CLAIM]));+ const page = outcome(await run(`INSERT INTO pages (slug, type, title, compiled_truth, content_hash) VALUES ('notes/again-example', 'note', 't', 'x', $1) RETURNING id`, [PURGED_HASH]));+ const take = outcome(await run(`INSERT INTO takes (page_id, row_num, claim, kind, holder) VALUES ($1, 1, $2, 'take', 'alice-example') RETURNING id`, [ids.takes, PURGED_TAKE]));+ const derivation = outcome(await run(`INSERT INTO page_segment_derivations (page_id, pipeline, occurrence_id, pipeline_version, segment_sha256, context_hash, state, output)+ VALUES ($1, 'links', 1, 1, ${SHA}, ${SHA}, 'done', $2::jsonb) RETURNING 1 AS stored`, [ids.derived, JSON.stringify({ text: PURGED_CLAIM })]));+ const [w] = rowsOf(await run(`INSERT INTO facts (fact, source) VALUES ($1, 'probe') RETURNING id`, [WITHDRAWN_CLAIM]));+ const [stamped] = rowsOf(await run('SELECT expired_at IS NOT NULL AS expired FROM facts WHERE id = $1', [w!.id]));+ return { fact, page, take, derivation, withdrawn: stamped!.expired ? 'expired' : 'active' };+ }+ const REFUSED = { fact: 'purged_content', page: 'purged_content', take: 'purged_content', derivation: 'stored 0', withdrawn: 'expired' };++ test('1. without a shadow, the owner and a non-owner writer have a purged fact, page and take refused, a purged derivation dropped and a withdrawn fact stamped', async () => {+ for (const role of [owner, WRITER]) {+ expect({ role, ...(await as(conn, role, guardedWrites)) }).toEqual({ role, ...REFUSED });+ }+ });++ test('2. a temp table or view named like each ledger hides nothing, for the owner and for a non-owner writer', async () => {+ for (const role of [owner, WRITER]) {+ for (const kind of ['TABLE', 'VIEW']) {+ const result = await as(conn, role, async run => {+ for (const ledger of SHADOWED) {+ rowsOf(await run(kind === 'TABLE' ? `CREATE TEMP TABLE ${ledger} (LIKE public.${ledger})` : `CREATE TEMP VIEW ${ledger} AS SELECT * FROM public.${ledger} WHERE false`));+ }+ return guardedWrites(run);+ });+ expect({ role, kind, ...result }).toEqual({ role, kind, ...REFUSED });+ }+ }+ });++ test('3. after a fresh install: no SECURITY DEFINER function, the guard triggers as on master, every pinned search_path ends in pg_temp', async () => {+ const c = await catalog(conn);+ expect(c.definers).toEqual([]);+ expect(c.triggers).toEqual([+ { trigger: 'facts_guard_inserted', timing: 'AFTER' },+ { trigger: 'facts_preserve_withdrawal', timing: 'BEFORE' },+ { trigger: 'facts_refuse_purged', timing: 'BEFORE' },+ { trigger: 'page_segment_derivations_refuse_purging', timing: 'BEFORE' },+ { trigger: 'pages_refuse_purged', timing: 'BEFORE' },+ { trigger: 'takes_refuse_purged', timing: 'BEFORE' },+ ]);+ expect(c.pinned).toBeGreaterThanOrEqual(35);+ expect(c.withoutTemp).toEqual([]);+ });++ test('4. a brain at the version before, migrated (no schema blob replay), ends the same, and doctor passes only after', async () => {+ const { functionSearchPathProblems } = await import('../../src/commands/doctor/checks/function-search-path.ts');+ const brain = await freshBrain();+ const engine = new PostgresEngine();+ try {+ await rewind(brain.conn);+ const before = await catalog(brain.conn);+ expect(before.withoutTemp.length).toBe(before.pinned);+ await engine.connect({ database_url: brain.url });+ expect((await functionSearchPathProblems(engine)).functions.length).toBe(before.pinned);+ const { value, stderr } = await capturingStderr(() => runMigrations(engine));+ expect(value.current).toBe(LATEST_VERSION);+ expect(stderr).not.toContain('left without pg_temp');+ expect(await catalog(brain.conn)).toEqual(await catalog(conn));+ expect(await functionSearchPathProblems(engine)).toEqual({ functions: [], fix: [] });+ } finally {+ await engine.disconnect();+ await brain.conn.end();+ }+ }, 300_000);++ test('5. a migrating role that owns every table and function but one finishes, names that one, and the printed fix (as its owner) clears it; the migrating role then boots', async () => {+ const { functionSearchPathProblems } = await import('../../src/commands/doctor/checks/function-search-path.ts');+ const brain = await freshBrain();+ const migrator = `gbrain_test_path_migrator_${suffix}`;+ const other = `gbrain_test_path_other_${suffix}`;+ await admin!.unsafe(`CREATE ROLE ${migrator} LOGIN PASSWORD 'migrator' NOSUPERUSER BYPASSRLS; CREATE ROLE ${other} NOLOGIN NOSUPERUSER`);+ createdRoles.push(migrator, other);+ const engine = new PostgresEngine();+ try {+ await rewind(brain.conn);+ await brain.conn.unsafe(`GRANT USAGE, CREATE ON SCHEMA public TO ${migrator};+ DO $$ DECLARE r RECORD; BEGIN+ FOR r IN SELECT c.oid::regclass AS rel FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace+ WHERE n.nspname = 'public' AND c.relkind IN ('r', 'p', 'v', 'm', 'S')+ AND NOT EXISTS (SELECT 1 FROM pg_depend d WHERE d.objid = c.oid AND d.deptype IN ('e', 'a', 'i')) LOOP+ EXECUTE format('ALTER TABLE %s OWNER TO ${migrator}', r.rel);+ END LOOP;+ FOR r IN SELECT p.oid::regprocedure AS sig FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace+ WHERE n.nspname = 'public' AND NOT EXISTS (SELECT 1 FROM pg_depend d WHERE d.objid = p.oid AND d.deptype = 'e') LOOP+ EXECUTE format('ALTER ROUTINE %s OWNER TO ${migrator}', r.sig);+ END LOOP; END $$;+ ALTER FUNCTION gbrain_refuse_purged_fact() OWNER TO ${other}`);+ const asMigrator = new URL(brain.url);+ asMigrator.username = migrator;+ asMigrator.password = 'migrator';+ await engine.connect({ database_url: asMigrator.toString() });+ const { value, stderr } = await capturingStderr(() => runMigrations(engine));+ expect(value.current).toBe(LATEST_VERSION);+ expect(stderr).toContain('1 function(s) left without pg_temp on their search_path (gbrain_refuse_purged_fact())');+ expect((await catalog(brain.conn)).withoutTemp).toEqual(['gbrain_refuse_purged_fact()']);+ const { functions, fix } = await functionSearchPathProblems(engine);+ expect({ functions, fix }).toEqual({+ functions: ['gbrain_refuse_purged_fact()'],+ fix: ['ALTER FUNCTION gbrain_refuse_purged_fact() SET search_path = pg_catalog, public, pg_temp;'],+ });+ await brain.conn.unsafe(`SET ROLE ${other}; ${fix.join('\n')} RESET ROLE;`);+ expect(await functionSearchPathProblems(engine)).toEqual({ functions: [], fix: [] });+ await engine.initSchema();+ expect(await functionSearchPathProblems(engine)).toEqual({ functions: [], fix: [] });+ expect((await catalog(brain.conn)).withoutTemp).toEqual([]);+ } finally {+ await engine.disconnect().catch(() => {});+ await brain.conn.end();+ }+ }, 300_000);++ test('6. a brain at the latest version that boots again (schema blob replay, no migration) keeps pg_temp on every pinned path', async () => {+ const engine = new PostgresEngine();+ try {+ await engine.connect({ database_url: url });+ const { value } = await capturingStderr(() => runMigrations(engine));+ expect(value.applied).toBe(0);+ const before = await catalog(conn);+ await engine.initSchema();+ expect(await catalog(conn)).toEqual(before);+ } finally {+ await engine.disconnect();+ }+ }, 300_000);++ test('7. v276 refuses with schema_lock_blocked while another session holds a function it alters, and finishes after', async () => {+ const { v276 } = await import('../../src/core/schema-migrations/v276-function-search-path-pg-temp.ts');+ const { withEnv } = await import('../helpers/with-env.ts');+ const engine = new PostgresEngine();+ const holder = postgres(url, { max: 1, prepare: false, onnotice: () => {} });+ try {+ await conn.unsafe('ALTER FUNCTION gbrain_try_jsonb(text) SET search_path = pg_catalog, public');+ await engine.connect({ database_url: url });+ const session = await holder.reserve();+ try {+ await session.unsafe(`BEGIN; ALTER FUNCTION gbrain_try_jsonb(text) SET statement_timeout = '1min'`);+ const error = await withEnv({ GBRAIN_SCHEMA_LOCK_TIMEOUT_SECONDS: '1' }, () => v276.handler!(engine).then(() => null, (e: unknown) => e));+ expect(error).toMatchObject({ code: 'schema_lock_blocked', detail: 'v276 search_path' });+ expect((await catalog(conn)).withoutTemp).toEqual(['gbrain_try_jsonb(text)']);+ } finally {+ await session.unsafe('ROLLBACK');+ session.release();+ }+ await withEnv({ GBRAIN_SCHEMA_LOCK_TIMEOUT_SECONDS: '1' }, () => v276.handler!(engine));+ expect((await catalog(conn)).withoutTemp).toEqual([]);+ } finally {+ await holder.end();+ await engine.disconnect();+ }+ }, 120_000);+});diff --git a/test/e2e/guard-definer-postgres.test.ts b/test/e2e/guard-definer-postgres.test.tsdeleted file mode 100644index 81a79aacae..0000000000--- a/test/e2e/guard-definer-postgres.test.ts+++ /dev/null@@ -1,645 +0,0 @@-/**- * The purge and withdrawal guards hold under a scoped write role, and running them as their owner opens nothing- * (#7632, src/core/guard-definer.ts). Real Postgres: a role that may write every gbrain table except the purge and- * withdrawal ledgers (NOLOGIN, NOBYPASSRLS, not the owner), and Supabase-style `anon`/`authenticated` roles that- * hold the default table and function grants and no policy.- *- * Before #7632 the guards were SECURITY INVOKER: under that role a ledger read returned no row, so a purged claim,- * page, take or derivation was stored again and a withdrawn fact was saved active. Cases 6-9 pin the holes a definer- * could open: a temp table or view named like a ledger (the caller's temp schema is searched first unless pg_temp is- * named last), a BEFORE ROW definer answering a role RLS refuses (case 17: a role that can read the page but whose- * derivation row RLS refuses), and direct calls.- * Run: DATABASE_URL=... bun test test/e2e/guard-definer-postgres.test.ts- */-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';-import { randomUUID } from 'node:crypto';-import postgres from '#postgres';-import { assertSafeE2eDatabaseUrl } from '../helpers/db-guard.ts';-import { PostgresEngine } from '../../src/core/postgres-engine.ts';-import { LATEST_VERSION, runMigrations } from '../../src/core/migrate.ts';-import { guardFunctionProblems } from '../../src/commands/doctor/checks/guard-functions.ts';-import { derivationNeedles } from '../../src/core/page-body/segment-derive.ts';-import { DerivationWriteRefused } from '../../src/core/page-body/derivations.ts';-import { MEMORY_PURGE_GUARD_SQL } from '../../src/core/facts/purge-schema.ts';-import { FACT_INSERT_GUARD_SQL } from '../../src/core/facts/insert-guard-schema.ts';-import { v276 } from '../../src/core/schema-migrations/v276-guard-triggers-security-definer.ts';-import { withEnv } from '../helpers/with-env.ts';--const DATABASE_URL = process.env.DATABASE_URL;-const describeE2E = DATABASE_URL ? describe : describe.skip;--type Sql = ReturnType<typeof postgres>;-type Outcome = { rows: Array<Record<string, unknown>> } | { code: string; message: string };--const GUARDS = ['gbrain_mark_derivation_scope_entry', 'gbrain_refuse_purged_fact', 'gbrain_refuse_purged_page', 'gbrain_refuse_purged_take',- 'gbrain_refuse_revived_withdrawn_fact', 'gbrain_refuse_stored_purging_derivation', 'gbrain_refuse_unguarded_inserted_facts'];-/** The definer guards #7632 adds; the rest existed before as invokers. */-const NEW_GUARDS = ['gbrain_refuse_revived_withdrawn_fact', 'gbrain_refuse_stored_purging_derivation', 'gbrain_refuse_unguarded_inserted_facts'];-const GUARD_TRIGGER_NAMES = ['facts_refuse_purged', 'facts_refuse_revived_withdrawal', 'facts_refuse_unguarded_inserted', 'pages_refuse_purged',- 'page_segment_derivations_refuse_stored_purging', 'takes_refuse_purged'];-const DEFINER_PATH = ['search_path=pg_catalog, pg_temp'];-const LEDGERS = ['fact_purges', 'fact_withdrawals', 'take_purges', 'page_purges', 'page_segment_derivation_purges', 'page_segment_derivation_purge_pages'];-const API_ROLES = ['anon', 'authenticated'];--const PURGED_CLAIM = 'alice-example joined acme-example as cto';-const WITHDRAWN_CLAIM = 'alice-example lives in city-a';-const PURGED_TAKE = 'acme-example will double revenue';-const PURGED_HASH = 'deadbeefcafe00000000000000000001';-const SHA = `decode(repeat('ab', 32), 'hex')`;--const suffix = randomUUID().replaceAll('-', '').slice(0, 12);-const WRITER = `gbrain_test_guard_writer_${suffix}`;-const scratch: string[] = [];-const createdRoles: string[] = [];-let admin: Sql | null = null;--function urlFor(name: string): string {- const url = new URL(DATABASE_URL!);- url.pathname = `/${name}`;- return url.toString();-}--/** A freshly initialized brain whose public schema grants anon and authenticated what Supabase's default privileges do. */-async function supabaseShapedBrain(): Promise<{ url: string; conn: Sql }> {- assertSafeE2eDatabaseUrl(DATABASE_URL!);- const name = `gbrain_test_guard_${randomUUID().replaceAll('-', '')}`;- await admin!.unsafe(`CREATE DATABASE ${name}`);- scratch.push(name);- const url = urlFor(name);- const conn = postgres(url, { max: 1, prepare: false, onnotice: () => {} });- await conn.unsafe(`GRANT USAGE ON SCHEMA public TO anon, authenticated;- ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON TABLES TO anon, authenticated;- ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON SEQUENCES TO anon, authenticated;- ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON FUNCTIONS TO anon, authenticated`);- const engine = new PostgresEngine();- await engine.connect({ database_url: url });- try { await engine.initSchema(); } finally { await engine.disconnect(); }- return { url, conn };-}--/** Runs `fn` as `role` in one transaction that is rolled back; each `run` is its own savepoint. */-async function as<T>(conn: Sql, role: string, fn: (run: (sql: string, params?: unknown[]) => Promise<Outcome>) => Promise<T>): Promise<T> {- const session = await conn.reserve();- try {- await session.unsafe('BEGIN');- await session.unsafe(`SET LOCAL ROLE ${role}`);- return await fn(async (sql, params) => {- await session.unsafe('SAVEPOINT attempt');- try {- const rows = await session.unsafe(sql, params as never[]);- await session.unsafe('RELEASE SAVEPOINT attempt');- return { rows: [...rows] as Array<Record<string, unknown>> };- } catch (error) {- await session.unsafe('ROLLBACK TO SAVEPOINT attempt');- const e = error as { code?: string; message?: string };- return { code: String(e.code), message: String(e.message) };- }- });- } finally {- await session.unsafe('ROLLBACK').catch(() => {});- session.release();- }-}--const rowsOf = (o: Outcome) => ('rows' in o ? o.rows : (() => { throw new Error(`expected rows, got ${o.code}: ${o.message}`); })());-const failure = (o: Outcome) => ('code' in o ? { code: o.code, message: o.message } : { code: 'none', message: `stored ${o.rows.length} row(s)` });--describeE2E('purge and withdrawal guards under a scoped write role (#7632)', () => {- let conn: Sql;- let url: string;- const ids: Record<string, number> = {};- let withdrawnAt = '';- const request = randomUUID();-- beforeAll(async () => {- assertSafeE2eDatabaseUrl(DATABASE_URL!);- admin = postgres(DATABASE_URL!, { max: 1, prepare: false, onnotice: () => {} });- for (const role of API_ROLES) {- if ((await admin.unsafe('SELECT 1 FROM pg_roles WHERE rolname = $1', [role])).length > 0) continue;- await admin.unsafe(`CREATE ROLE ${role} NOLOGIN NOBYPASSRLS`);- createdRoles.push(role);- }- await admin.unsafe(`CREATE ROLE ${WRITER} NOLOGIN NOSUPERUSER NOBYPASSRLS`);- createdRoles.push(WRITER);- ({ url, conn } = await supabaseShapedBrain());- // The writer may read and write every gbrain table except the ledgers: the configuration the guards failed open under.- await conn.unsafe(`GRANT USAGE ON SCHEMA public TO ${WRITER};- GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO ${WRITER};- GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO ${WRITER};- DO $$ DECLARE t RECORD; BEGIN- FOR t IN SELECT c.oid::regclass AS rel FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace- WHERE n.nspname = 'public' AND c.relkind IN ('r', 'p') AND c.relrowsecurity AND NOT c.relname = ANY(ARRAY['${LEDGERS.join("','")}']) LOOP- EXECUTE format('CREATE POLICY gbrain_test_writer ON %s TO ${WRITER} USING (true) WITH CHECK (true)', t.rel);- END LOOP; END $$`);- expect((await conn.unsafe(`SELECT relname FROM pg_class WHERE relname = ANY($1::text[]) AND relrowsecurity ORDER BY 1`, [LEDGERS])).length).toBe(LEDGERS.length);-- for (const [key, slug] of [['takes', 'people/alice-example'], ['derived', 'notes/derivation-example'], ['deleted', 'notes/soon-deleted-example']]) {- const [row] = await conn.unsafe<Array<{ id: number }>>(`INSERT INTO pages (slug, type, title, compiled_truth) VALUES ($1, 'note', $1, 'x') RETURNING id`, [slug]);- ids[key] = row!.id;- }- await conn.unsafe(`INSERT INTO fact_purges (source_id, visibility, subject, fact_hash) VALUES ('default', 'private', '*', gbrain_fact_fingerprint($1))`, [PURGED_CLAIM]);- const [w] = await conn.unsafe<Array<{ at: string }>>(- `INSERT INTO fact_withdrawals (source_id, visibility, subject, fact_hash) VALUES ('default', 'private', '*', gbrain_fact_fingerprint($1)) RETURNING withdrawn_at::text AS at`, [WITHDRAWN_CLAIM]);- withdrawnAt = w!.at;- await conn.unsafe(`INSERT INTO page_purges (source_id, content_hash, slug) VALUES ('default', $1, 'notes/purged-example')`, [PURGED_HASH]);- await conn.unsafe(`INSERT INTO take_purges (source_id, subject, claim_hash) VALUES ('default', '*', gbrain_fact_fingerprint($1))`, [PURGED_TAKE]);- const { needles, patterns } = await derivationNeedles({ executeRaw: (sql: string, params?: unknown[]) => conn.unsafe(sql, params as never[]) } as never, [PURGED_CLAIM]);- await conn.unsafe(`INSERT INTO page_segment_derivation_purges (request_id, source_id, needles, patterns, page_ids) VALUES ($1::uuid, 'default', $2::text[], $3::text[], $4::int[])`,- [request, needles, patterns, [ids.derived]]);- }, 300_000);-- afterAll(async () => {- await conn?.end();- if (admin) {- for (const name of scratch) await admin.unsafe(`DROP DATABASE IF EXISTS ${name} WITH (FORCE)`);- for (const role of createdRoles) await admin.unsafe(`DROP ROLE IF EXISTS ${role}`).catch(() => {});- await admin.end();- }- });-- const insertDerivation = (output: string) => [`INSERT INTO page_segment_derivations (page_id, pipeline, occurrence_id, pipeline_version, segment_sha256, context_hash, state, output)- VALUES ($1, 'links', $2, 1, ${SHA}, ${SHA}, 'done', $3::jsonb) RETURNING 1 AS stored`, output] as const;-- test('1. a purged claim is refused: a multi-row insert and an update into it', async () => {- await as(conn, WRITER, async run => {- expect(failure(await run(`INSERT INTO facts (fact, source) VALUES ('an unrelated claim', 'probe'), ($1, 'probe')`, [PURGED_CLAIM])))- .toEqual({ code: 'P0001', message: expect.stringContaining('purged_content: this claim was purged') });- const [row] = rowsOf(await run(`INSERT INTO facts (fact, source) VALUES ('an unrelated claim', 'probe') RETURNING id`));- expect(failure(await run('UPDATE facts SET fact = $1 WHERE id = $2', [PURGED_CLAIM, row!.id])))- .toEqual({ code: 'P0001', message: expect.stringContaining('purged_content: this claim was purged') });- });- });-- test('2. a withdrawn claim stays withdrawn: an owner is stamped as before; a writer that cannot read the withdrawals is refused on a row insert, a deferred insert and an update clearing expired_at', async () => {- await as(conn, WRITER, async run => {- expect(failure(await run(`INSERT INTO facts (fact, source) VALUES ($1, 'probe')`, [WITHDRAWN_CLAIM])))- .toMatchObject({ code: 'P0001', message: expect.stringContaining('fact_withdrawn:') });- rowsOf(await run(`SET LOCAL gbrain.fact_withdrawal_stamp_deferred = 'on'`));- expect(failure(await run(`INSERT INTO facts (fact, source) VALUES ($1, 'probe-deferred')`, [WITHDRAWN_CLAIM])))- .toMatchObject({ code: 'P0001', message: expect.stringContaining('fact_withdrawn:') });- rowsOf(await run('RESET ROLE'));- const [deferred] = rowsOf(await run(`INSERT INTO facts (fact, source) VALUES ($1, 'probe-deferred') RETURNING id`, [WITHDRAWN_CLAIM]));- rowsOf(await run(`SET LOCAL gbrain.fact_withdrawal_stamp_deferred = 'off'`));- expect(rowsOf(await run('SELECT expired_at::text AS at FROM facts WHERE id = $1', [deferred!.id]))).toEqual([{ at: withdrawnAt }]);- rowsOf(await run('UPDATE facts SET expired_at = NULL, valid_until = NULL WHERE id = $1', [deferred!.id]));- expect(rowsOf(await run('SELECT expired_at::text AS at FROM facts WHERE id = $1', [deferred!.id]))).toEqual([{ at: withdrawnAt }]);- rowsOf(await run(`SET LOCAL ROLE ${WRITER}`));- expect(failure(await run('UPDATE facts SET expired_at = NULL, valid_until = NULL WHERE id = $1', [deferred!.id])))- .toMatchObject({ code: 'P0001', message: expect.stringContaining('fact_withdrawn:') });- expect(rowsOf(await run('SELECT expired_at::text AS at FROM facts WHERE id = $1', [deferred!.id]))).toEqual([{ at: withdrawnAt }]);- });- });-- test('3. purged page content and a purged take claim are refused', async () => {- await as(conn, WRITER, async run => {- expect(failure(await run(`INSERT INTO pages (slug, type, title, compiled_truth, content_hash) VALUES ('notes/again-example', 'note', 't', 'x', $1)`, [PURGED_HASH])))- .toEqual({ code: 'P0001', message: expect.stringContaining('purged_content: this page content was purged') });- expect(failure(await run('UPDATE pages SET content_hash = $1 WHERE id = $2', [PURGED_HASH, ids.takes])))- .toEqual({ code: 'P0001', message: expect.stringContaining('purged_content: this page content was purged') });- expect(failure(await run(`INSERT INTO takes (page_id, row_num, claim, kind, holder) VALUES ($1, 1, $2, 'take', 'alice-example')`, [ids.takes, PURGED_TAKE])))- .toEqual({ code: 'P0001', message: expect.stringContaining('purged_content: this take claim was purged') });- });- });-- test('4. a derivation holding a purged claim during its sweep is refused for a writer that cannot read the sweep; an unrelated one is stored', async () => {- await as(conn, WRITER, async run => {- const [held, heldOutput] = insertDerivation(JSON.stringify({ text: PURGED_CLAIM }));- expect(failure(await run(held, [ids.derived, 1, heldOutput]))).toMatchObject({ code: 'P0001', message: expect.stringContaining('derivation_purge_pending:') });- const [other, otherOutput] = insertDerivation(JSON.stringify({ text: 'an unrelated link context' }));- expect(rowsOf(await run(other, [ids.derived, 2, otherOutput]))).toEqual([{ stored: 1 }]);- // Generated by gstack /ship coverage audit (#7642).- // Value: protects=the AFTER ROW stored check refuses an UPDATE that rewrites a stored derivation into a purged claim- // during its sweep; fails_when=the stored trigger stops firing on UPDATE OF output, receipt (INSERT only);- // why_new=case 4 inserted only, and the catalog goldens are regenerated with each schema change; seam=none;- // no_claim=an UPDATE of receipt alone (same trigger column list, not exercised)- expect(failure(await run('UPDATE page_segment_derivations SET output = $1::jsonb WHERE page_id = $2 AND occurrence_id = 2', [heldOutput, ids.derived])))- .toMatchObject({ code: 'P0001', message: expect.stringContaining('derivation_purge_pending:') });- });- });-- test('5. a page soft-deleted during a derivation sweep is noted for the sweep', async () => {- await as(conn, WRITER, async run => {- rowsOf(await run('UPDATE pages SET deleted_at = now() WHERE id = $1', [ids.deleted]));- rowsOf(await run('RESET ROLE'));- expect(rowsOf(await run('SELECT page_id FROM page_segment_derivation_purge_pages WHERE request_id = $1::uuid', [request])))- .toEqual([{ page_id: ids.deleted }]);- });- });-- test('6. temp tables named like the ledgers do not hide them', async () => {- await as(conn, WRITER, async run => {- for (const ledger of LEDGERS) rowsOf(await run(`CREATE TEMP TABLE ${ledger} (LIKE public.${ledger})`));- expect(failure(await run(`INSERT INTO facts (fact, source) VALUES ($1, 'probe')`, [PURGED_CLAIM])).code).toBe('P0001');- expect(failure(await run(`INSERT INTO facts (fact, source) VALUES ($1, 'probe')`, [WITHDRAWN_CLAIM]))).toMatchObject({ code: 'P0001', message: expect.stringContaining('fact_withdrawn:') });- expect(failure(await run(`INSERT INTO pages (slug, type, title, compiled_truth, content_hash) VALUES ('notes/again-example', 'note', 't', 'x', $1)`, [PURGED_HASH])).code).toBe('P0001');- expect(failure(await run(`INSERT INTO takes (page_id, row_num, claim, kind, holder) VALUES ($1, 1, $2, 'take', 'alice-example')`, [ids.takes, PURGED_TAKE])).code).toBe('P0001');- const [held, heldOutput] = insertDerivation(JSON.stringify({ text: PURGED_CLAIM }));- expect(failure(await run(held, [ids.derived, 1, heldOutput])).code).toBe('P0001');- });- });-- test('7. a temp view named like a ledger never runs the caller\'s code (as the owner or at all)', async () => {- await as(conn, WRITER, async run => {- rowsOf(await run('CREATE TEMP TABLE witness (who text)'));- for (const ledger of ['page_purges', 'fact_purges']) {- rowsOf(await run(`CREATE FUNCTION pg_temp.spy_${ledger}() RETURNS SETOF public.${ledger} LANGUAGE plpgsql AS $f$- BEGIN INSERT INTO pg_temp.witness VALUES (current_user); RETURN; END $f$`));- rowsOf(await run(`CREATE TEMP VIEW ${ledger} AS SELECT * FROM pg_temp.spy_${ledger}()`));- }- const purgedPage = failure(await run(`INSERT INTO pages (slug, type, title, compiled_truth, content_hash) VALUES ('notes/again-example', 'note', 't', 'x', $1)`, [PURGED_HASH]));- const purgedFact = failure(await run(`INSERT INTO facts (fact, source) VALUES ($1, 'probe')`, [PURGED_CLAIM]));- rowsOf(await run(`INSERT INTO pages (slug, type, title, compiled_truth, content_hash) VALUES ('notes/fine-example', 'note', 't', 'x', 'feedface')`));- rowsOf(await run(`INSERT INTO facts (fact, source) VALUES ('an unrelated claim', 'probe')`));- expect(rowsOf(await run('SELECT DISTINCT who FROM pg_temp.witness'))).toEqual([]);- expect([purgedPage.code, purgedFact.code]).toEqual(['P0001', 'P0001']);- });- });-- test('8. a role RLS refuses gets the same error for purged and unpurged content (no existence oracle)', async () => {- for (const role of API_ROLES) {- await as(conn, role, async run => {- const page = (hash: string) => run(`INSERT INTO pages (slug, type, title, compiled_truth, content_hash) VALUES ('notes/probe-example', 'note', 't', 'x', $1)`, [hash]);- expect(failure(await page(PURGED_HASH))).toEqual(failure(await page('feedface00000000')));- expect(failure(await page(PURGED_HASH)).code).toBe('42501');- const take = (claim: string) => run(`INSERT INTO takes (page_id, row_num, claim, kind, holder) VALUES ($1, 1, $2, 'take', 'alice-example')`, [ids.takes, claim]);- expect(failure(await take(PURGED_TAKE))).toEqual(failure(await take('an unrelated take')));- const fact = (claim: string) => run(`INSERT INTO facts (fact, source) VALUES ($1, 'probe')`, [claim]);- expect(failure(await fact(PURGED_CLAIM))).toEqual(failure(await fact('an unrelated claim')));- const [sql] = insertDerivation('{}');- const derivation = (text: string) => run(sql, [ids.derived, 9, JSON.stringify({ text })]);- expect(failure(await derivation(PURGED_CLAIM))).toEqual(failure(await derivation('an unrelated link context')));- expect(failure(await derivation(PURGED_CLAIM)).code).toBe('42501');- });- }- });-- test('9. no guard can be called directly', async () => {- for (const role of [WRITER, ...API_ROLES]) {- await as(conn, role, async run => {- for (const fn of GUARDS) expect({ fn, ...failure(await run(`SELECT ${fn}()`)) }).toMatchObject({ fn, code: '42501' });- });- }- });-- /** The definer posture of the guards and the search_path of every function that pins one. */- async function catalog(c: Sql) {- const guards = await c.unsafe<Array<{ fn: string; secdef: boolean; config: string[] | null; executable_by: string[] }>>(- `SELECT p.proname AS fn, p.prosecdef AS secdef, p.proconfig AS config,- ARRAY(SELECT 'PUBLIC' WHERE EXISTS (SELECT 1 FROM aclexplode(COALESCE(p.proacl, acldefault('f', p.proowner))) a WHERE a.grantee = 0 AND a.privilege_type = 'EXECUTE')- UNION ALL SELECT r.rolname::text FROM pg_roles r WHERE r.rolname = ANY($2::text[]) AND has_function_privilege(r.oid, p.oid, 'EXECUTE')) AS executable_by- FROM pg_proc p WHERE p.oid = ANY(SELECT to_regprocedure(g || '()') FROM unnest($1::text[]) g) ORDER BY 1`, [GUARDS, API_ROLES]);- const triggers = await c.unsafe<Array<{ trigger: string; timing: string }>>(- `SELECT tgname AS trigger, CASE WHEN (tgtype & 2) <> 0 THEN 'BEFORE' ELSE 'AFTER' END AS timing FROM pg_trigger WHERE NOT tgisinternal- AND tgname = ANY($1::text[]) ORDER BY 1`, [[...GUARD_TRIGGER_NAMES, 'page_segment_derivations_refuse_purging']]);- const definers = await c.unsafe<Array<{ fn: string; config: string[] | null }>>(- `SELECT p.proname AS fn, p.proconfig AS config FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace- WHERE n.nspname = 'public' AND p.prosecdef ORDER BY 1`);- const pathsWithoutTemp = await c.unsafe<Array<{ sig: string }>>(- `SELECT p.oid::regprocedure::text AS sig FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace CROSS JOIN LATERAL unnest(p.proconfig) AS s(setting)- WHERE n.nspname = 'public' AND s.setting LIKE 'search_path=%' AND s.setting NOT LIKE '%, pg_temp' ORDER BY 1`);- return {- guards: guards.map(g => ({ fn: g.fn, secdef: g.secdef, config: g.config, executable_by: g.executable_by })),- triggers: triggers.map(t => ({ trigger: t.trigger, timing: t.timing })),- pathsWithoutTemp: pathsWithoutTemp.map(p => p.sig),- definers: definers.map(d => ({ fn: d.fn, config: d.config })),- };- }-- const EXPECTED = {- guards: GUARDS.map(fn => ({ fn, secdef: true, config: DEFINER_PATH, executable_by: [] })),- triggers: [- { trigger: 'facts_refuse_purged', timing: 'AFTER' },- { trigger: 'facts_refuse_revived_withdrawal', timing: 'AFTER' },- { trigger: 'facts_refuse_unguarded_inserted', timing: 'AFTER' },- { trigger: 'page_segment_derivations_refuse_purging', timing: 'BEFORE' },- { trigger: 'page_segment_derivations_refuse_stored_purging', timing: 'AFTER' },- { trigger: 'pages_refuse_purged', timing: 'AFTER' },- { trigger: 'takes_refuse_purged', timing: 'AFTER' },- ],- pathsWithoutTemp: [],- // Every SECURITY DEFINER function in public is one of the guards, with public off its path: a redefinition that- // puts public back, or a new definer, fails here.- definers: GUARDS.map(fn => ({ fn, config: DEFINER_PATH })),- };-- test('10a. after a fresh install: guards are definers pinned to pg_catalog, pg_temp (the only definers in public), not executable by PUBLIC/anon/authenticated, raising triggers AFTER ROW, every pinned search_path ends in pg_temp', async () => {- expect(await catalog(conn)).toEqual(EXPECTED);- });-- /** Puts a brain back in the shape every brain had before #7632, at the version before it. */- /** Puts a brain back in the shape every brain had before #7632, at the version before it. */- async function rewind(c: Sql): Promise<void> {- await c.unsafe(`- ${MEMORY_PURGE_GUARD_SQL}- ${FACT_INSERT_GUARD_SQL}- GRANT EXECUTE ON FUNCTION gbrain_refuse_purged_fact(), gbrain_refuse_purged_take(), gbrain_refuse_purged_page() TO PUBLIC, anon, authenticated;- DROP TRIGGER facts_refuse_revived_withdrawal ON facts;- DROP FUNCTION gbrain_refuse_revived_withdrawn_fact();- DROP TRIGGER facts_refuse_unguarded_inserted ON facts;- DROP FUNCTION gbrain_refuse_unguarded_inserted_facts();- DROP TRIGGER page_segment_derivations_refuse_stored_purging ON page_segment_derivations;- DROP FUNCTION gbrain_refuse_stored_purging_derivation();- ALTER FUNCTION gbrain_mark_derivation_scope_entry() SECURITY INVOKER SET search_path = pg_catalog, public;- GRANT EXECUTE ON FUNCTION gbrain_mark_derivation_scope_entry() TO PUBLIC, anon, authenticated;- DO $$ DECLARE f RECORD; BEGIN- FOR f IN SELECT p.oid::regprocedure AS sig, substr(s.setting, 13) AS path FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace- CROSS JOIN LATERAL unnest(p.proconfig) AS s(setting) WHERE n.nspname = 'public' AND s.setting LIKE 'search_path=%, pg_temp' LOOP- EXECUTE format('ALTER FUNCTION %s SET search_path = %s', f.sig, left(f.path, -9));- END LOOP; END $$;- UPDATE config SET value = '${LATEST_VERSION - 1}' WHERE key = 'version';`);- }-- async function capturingStderr<T>(fn: () => Promise<T>): Promise<{ value: T; stderr: string }> {- const write = process.stderr.write.bind(process.stderr);- let stderr = '';- process.stderr.write = ((chunk: string | Uint8Array) => { stderr += String(chunk); return true; }) as typeof process.stderr.write;- try { return { value: await fn(), stderr }; } finally { process.stderr.write = write; }- }-- test('10b. a brain at the version before, migrated (no schema blob replay), ends the same, and doctor passes only after', async () => {- const brain = await supabaseShapedBrain();- const engine = new PostgresEngine();- try {- await rewind(brain.conn);- expect((await catalog(brain.conn)).pathsWithoutTemp.length).toBeGreaterThan(30);- await engine.connect({ database_url: brain.url });- expect((await guardFunctionProblems(engine)).problems.length).toBeGreaterThan(0);- const { value, stderr } = await capturingStderr(() => runMigrations(engine));- expect(value.current).toBe(LATEST_VERSION);- expect(stderr).not.toContain('left as they were');- expect(await catalog(brain.conn)).toEqual(EXPECTED);- expect(await guardFunctionProblems(engine)).toEqual({ problems: [], fix: [] });- } finally {- await engine.disconnect();- await brain.conn.end();- }- }, 300_000);-- test('11. a migrating role that owns nothing names what it left and carries on; doctor fails with SQL that fixes it', async () => {- const brain = await supabaseShapedBrain();- const migrator = `gbrain_test_guard_migrator_${suffix}`;- await admin!.unsafe(`CREATE ROLE ${migrator} LOGIN PASSWORD 'migrator' NOSUPERUSER BYPASSRLS`);- createdRoles.push(migrator);- const owner = new PostgresEngine();- const notOwner = new PostgresEngine();- try {- await rewind(brain.conn);- await brain.conn.unsafe(`GRANT USAGE, CREATE ON SCHEMA public TO ${migrator}; GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO ${migrator}`);- const asMigrator = new URL(brain.url);- asMigrator.username = migrator;- asMigrator.password = 'migrator';- await notOwner.connect({ database_url: asMigrator.toString() });- const { value, stderr } = await capturingStderr(() => runMigrations(notOwner));- expect(value.current).toBe(LATEST_VERSION);- for (const fn of GUARDS) expect(stderr).toContain(`${fn}()`);- for (const trigger of GUARD_TRIGGER_NAMES) expect(stderr).toContain(trigger);- expect(stderr).toContain('left as they were');- // Generated by gstack /ship coverage audit (#7642).- // Value: protects=v276 names on stderr every non-guard function whose search_path it could not finish with pg_temp;- // fails_when=the unhardened-function listing is dropped from hardenGuards; why_new=the guard names above also come- // from the function loop; seam=none; no_claim=none beyond protects- expect(stderr).toContain('gbrain_try_jsonb(text)');- expect((await catalog(brain.conn)).guards.every(g => !g.secdef)).toBe(true);- await notOwner.disconnect();-- await owner.connect({ database_url: brain.url });- const { problems, fix } = await guardFunctionProblems(owner);- expect(problems.length).toBeGreaterThan(0);- await owner.executeRaw(fix.join('\n'));- expect(await guardFunctionProblems(owner)).toEqual({ problems: [], fix: [] });- expect(await catalog(brain.conn)).toEqual(EXPECTED);- } finally {- await notOwner.disconnect().catch(() => {});- await owner.disconnect().catch(() => {});- await brain.conn.end();- }- }, 300_000);-- // Generated by gstack /ship coverage audit (#7642).- // Value: protects=a brain already at the latest version that boots again (schema blob replay, no migration runs) keeps- // the definer guards, trigger placement and pg_temp on every pinned path; fails_when=the hardening fragment stops being- // the blob's last statement or a blob CREATE OR REPLACE drops SECURITY DEFINER; why_new=10a/10b run v276, which- // re-hardens everything; seam=none; no_claim=PGLite replay (pglite-upgrade-replay golden covers it)- test('12. a brain at the latest version that boots again (schema blob replay, no migration) keeps the catalog, and doctor passes', async () => {- const engine = new PostgresEngine();- try {- await engine.connect({ database_url: url });- const { value } = await capturingStderr(() => runMigrations(engine));- expect(value.applied).toBe(0);- await engine.initSchema();- expect(await catalog(conn)).toEqual(EXPECTED);- expect(await guardFunctionProblems(engine)).toEqual({ problems: [], fix: [] });- } finally {- await engine.disconnect();- }- }, 300_000);-- // Generated by gstack /ship coverage audit (#7642).- // Value: protects=doctor names a guard whose owner neither bypasses RLS nor owns its ledger, a guard that really lets- // purged content through; fails_when=the reads_under_rls probe is dropped or its owner/force condition inverted;- // why_new=every other case runs the guards as a superuser owner; seam=none; no_claim=FORCE ROW LEVEL SECURITY on an- // owner-owned ledger (same branch, not exercised)- test('13. doctor names a guard whose owner reads its ledger under RLS, and that guard does let purged content through', async () => {- const weakOwner = `gbrain_test_guard_owner_${suffix}`;- await admin!.unsafe(`CREATE ROLE ${weakOwner} NOLOGIN NOSUPERUSER NOBYPASSRLS`);- createdRoles.push(weakOwner);- const [fn] = await conn.unsafe<Array<{ owner: string }>>(`SELECT pg_get_userbyid(proowner) AS owner FROM pg_proc WHERE oid = 'gbrain_refuse_purged_page()'::regprocedure`);- const owner = fn!.owner;- const insertPurgedPage = `INSERT INTO pages (slug, type, title, compiled_truth, content_hash) VALUES ('notes/again-example', 'note', 't', 'x', $1) RETURNING 1 AS stored`;- const engine = new PostgresEngine();- try {- await conn.unsafe(`GRANT USAGE ON SCHEMA public TO ${weakOwner}; GRANT SELECT ON page_purges TO ${weakOwner};- ALTER FUNCTION gbrain_refuse_purged_page() OWNER TO ${weakOwner}`);- await engine.connect({ database_url: url });- expect(await guardFunctionProblems(engine)).toEqual({- problems: [`gbrain_refuse_purged_page()'s owner ${weakOwner} neither bypasses RLS nor owns page_purges unforced, so the guard reads them filtered`],- fix: ['/* give gbrain_refuse_purged_page() an owner that bypasses RLS and is not the role gbrain runs as, so that role stays under its policies: ALTER FUNCTION gbrain_refuse_purged_page() OWNER TO <that role>; */'],- });- await as(conn, WRITER, async run => {- expect(rowsOf(await run(insertPurgedPage, [PURGED_HASH]))).toEqual([{ stored: 1 }]);- });- } finally {- await conn.unsafe(`ALTER FUNCTION gbrain_refuse_purged_page() OWNER TO ${owner}; REVOKE ALL ON page_purges FROM ${weakOwner}; REVOKE USAGE ON SCHEMA public FROM ${weakOwner}`);- await engine.disconnect();- }- await as(conn, WRITER, async run => {- expect(failure(await run(insertPurgedPage, [PURGED_HASH])).code).toBe('P0001');- });- });-- // Generated by gstack /ship coverage audit (#7642).- // Value: protects=v276 stops with the typed schema_lock_blocked refusal naming the table when another session holds a- // lock, leaves that trigger as it was, and finishes once the lock is gone; fails_when=SET LOCAL lock_timeout or the- // 55P03 mapping is dropped (upgrade hangs or throws untyped); why_new=no test holds a lock against v276; seam=none;- // no_claim=the blocking-session sample (v276 passes sessions: null) and transaction-pooler behavior- test('14. v276 refuses with schema_lock_blocked when another session holds a lock on a table whose trigger it moves, and finishes after', async () => {- const engine = new PostgresEngine();- const holder = postgres(url, { max: 1, prepare: false, onnotice: () => {} });- const factsTiming = async () => (await catalog(conn)).triggers.find(t => t.trigger === 'facts_refuse_purged')?.timing;- try {- await conn.unsafe(`DROP TRIGGER facts_refuse_purged ON facts;- CREATE TRIGGER facts_refuse_purged BEFORE UPDATE OF fact, source_id, visibility, entity_slug ON facts FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_fact()`);- await engine.connect({ database_url: url });- const session = await holder.reserve();- try {- await session.unsafe('BEGIN; LOCK TABLE facts IN ACCESS SHARE MODE');- const error = await withEnv({ GBRAIN_SCHEMA_LOCK_TIMEOUT_SECONDS: '1' }, () => v276.handler!(engine).then(() => null, (e: unknown) => e));- expect(error).toMatchObject({ code: 'schema_lock_blocked', detail: 'v276 on facts' });- expect(await factsTiming()).toBe('BEFORE');- } finally {- await session.unsafe('ROLLBACK');- session.release();- }- await withEnv({ GBRAIN_SCHEMA_LOCK_TIMEOUT_SECONDS: '1' }, () => v276.handler!(engine));- expect(await catalog(conn)).toEqual(EXPECTED);- } finally {- await holder.end();- await engine.disconnect();- }- }, 300_000);-- test('15. a migrating role that owns the guards but not their tables leaves each raising guard an invoker while its trigger fires BEFORE ROW', async () => {- const brain = await supabaseShapedBrain();- const migrator = `gbrain_test_guard_fn_owner_${suffix}`;- await admin!.unsafe(`CREATE ROLE ${migrator} LOGIN PASSWORD 'migrator' NOSUPERUSER BYPASSRLS`);- createdRoles.push(migrator);- const engine = new PostgresEngine();- const exposed = ['gbrain_refuse_purged_fact', 'gbrain_refuse_purged_page', 'gbrain_refuse_purged_take'];- try {- await rewind(brain.conn);- await brain.conn.unsafe(`GRANT USAGE, CREATE ON SCHEMA public TO ${migrator}; GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO ${migrator};- ${GUARDS.filter(fn => !NEW_GUARDS.includes(fn)).map(fn => `ALTER FUNCTION ${fn}() OWNER TO ${migrator};`).join('\n')}`);- const asMigrator = new URL(brain.url);- asMigrator.username = migrator;- asMigrator.password = 'migrator';- await engine.connect({ database_url: asMigrator.toString() });- const { value, stderr } = await capturingStderr(() => runMigrations(engine));- expect(value.current).toBe(LATEST_VERSION);- for (const fn of [...exposed, ...NEW_GUARDS]) expect(stderr).toContain(`${fn}()`);- const after = await catalog(brain.conn);- expect(after.guards.map(g => [g.fn, g.secdef])).toEqual(GUARDS.filter(fn => !NEW_GUARDS.includes(fn)).map(fn => [fn, !exposed.includes(fn)]));- expect(after.triggers.map(t => [t.trigger, t.timing])).toEqual([- ['facts_refuse_purged', 'BEFORE'], ['page_segment_derivations_refuse_purging', 'BEFORE'], ['pages_refuse_purged', 'BEFORE'], ['takes_refuse_purged', 'BEFORE'],- ]);- } finally {- await engine.disconnect().catch(() => {});- await brain.conn.end();- }- }, 300_000);-- test('16. owners, roles that bypass RLS and writers with policies on the ledgers still have a derivation dropped and a withdrawn fact stamped silently', async () => {- const bypass = `gbrain_test_guard_bypass_${suffix}`;- const reader = `gbrain_test_guard_reader_${suffix}`;- await admin!.unsafe(`CREATE ROLE ${bypass} NOLOGIN NOSUPERUSER BYPASSRLS; CREATE ROLE ${reader} NOLOGIN NOSUPERUSER NOBYPASSRLS`);- createdRoles.push(bypass, reader);- await conn.unsafe(`GRANT USAGE ON SCHEMA public TO ${bypass}, ${reader};- GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO ${bypass}, ${reader};- GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO ${bypass}, ${reader};- DO $$ DECLARE t RECORD; BEGIN- FOR t IN SELECT c.oid::regclass AS rel FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace- WHERE n.nspname = 'public' AND c.relkind IN ('r', 'p') AND c.relrowsecurity LOOP- EXECUTE format('CREATE POLICY gbrain_test_reader ON %s TO ${reader} USING (true) WITH CHECK (true)', t.rel);- END LOOP; END $$`);- const [held, heldOutput] = insertDerivation(JSON.stringify({ text: PURGED_CLAIM }));- const [{ owner }] = await conn.unsafe<Array<{ owner: string }>>('SELECT current_user AS owner');- for (const role of [owner!, bypass, reader]) {- await as(conn, role, async run => {- expect({ role, rows: rowsOf(await run(held, [ids.derived, 1, heldOutput])) }).toEqual({ role, rows: [] });- expect({ role, rows: rowsOf(await run(`INSERT INTO facts (fact, source) VALUES ($1, 'probe') RETURNING expired_at::text AS at`, [WITHDRAWN_CLAIM])) })- .toEqual({ role, rows: [{ at: withdrawnAt }] });- });- }- const engine = new PostgresEngine();- try {- await engine.connect({ database_url: url });- const row = (occurrenceId: number, text: string) => ({ pageId: ids.derived!, kind: 'links' as const, occurrenceId, version: 1,- segmentSha256: new Uint8Array(32).fill(0xab), contextHash: new Uint8Array(32).fill(0xab), state: 'done' as const, output: { text }, receipt: null });- const refused = await engine.upsertSegmentDerivations([row(31, PURGED_CLAIM), row(32, 'an unrelated link context')]).then(() => null, (e: unknown) => e);- expect(refused).toBeInstanceOf(DerivationWriteRefused);- expect((refused as DerivationWriteRefused).refused).toBe(1);- expect((await conn.unsafe('SELECT occurrence_id::int AS o FROM page_segment_derivations WHERE page_id = $1 AND occurrence_id IN (31, 32) ORDER BY 1', [ids.derived]))- .map(r => r.o)).toEqual([32]);- } finally {- await conn.unsafe('DELETE FROM page_segment_derivations WHERE page_id = $1 AND occurrence_id IN (31, 32)', [ids.derived]);- await engine.disconnect();- }- });-- test('17. a role that can read the page but whose derivation row RLS refuses gets the same 42501 for a purged claim and unrelated text', async () => {- await conn.unsafe('CREATE POLICY gbrain_test_read_pages ON pages FOR SELECT TO authenticated USING (true)');- try {- await as(conn, 'authenticated', async run => {- expect(rowsOf(await run('SELECT id FROM pages WHERE id = $1', [ids.derived]))).toEqual([{ id: ids.derived }]);- const [sql] = insertDerivation('{}');- const derivation = (text: string) => run(sql, [ids.derived, 9, JSON.stringify({ text })]);- const purged = failure(await derivation(PURGED_CLAIM));- expect(purged).toEqual(failure(await derivation('an unrelated link context')));- expect(purged.code).toBe('42501');- });- } finally {- await conn.unsafe('DROP POLICY gbrain_test_read_pages ON pages');- }- });-- // A writer with CREATE on public (Supabase grants it to anon and authenticated) plants overloads of what the definer- // bodies call; each spy raises when it runs as anyone but the writer, so a definer that resolved it shows in the error.- test('18. overloads planted in public never run as the owner: hashtextextended, json_build_object, jsonb_path_query, gbrain_fact_fingerprint', async () => {- const spy = (signature: string, returns: string, call: string) => `CREATE FUNCTION public.${signature} RETURNS ${returns} LANGUAGE plpgsql AS $f$- BEGIN IF current_user <> '${WRITER}' THEN RAISE EXCEPTION 'spy % ran as %', '${signature.split('(')[0]}', current_user; END IF; ${call} END $f$`;- await conn.unsafe(`GRANT CREATE ON SCHEMA public TO ${WRITER}`);- try {- await as(conn, WRITER, async run => {- rowsOf(await run(spy('hashtextextended(a text, b integer)', 'bigint', 'RETURN pg_catalog.hashtextextended(a, b::bigint);')));- rowsOf(await run(spy('json_build_object(a text, b text, c text, d text)', 'json', 'RETURN pg_catalog.json_build_object(a, b, c, d);')));- rowsOf(await run(spy('jsonb_path_query(j jsonb, p text)', 'SETOF jsonb', 'RETURN QUERY SELECT pg_catalog.jsonb_path_query(j, p::jsonpath);')));- rowsOf(await run(spy('gbrain_fact_fingerprint(c character varying)', 'text', 'RETURN pg_catalog.md5(c);')));- const spied = (o: Outcome) => ('code' in o ? o.message : '').includes('spy ');- const softDelete = await run('UPDATE pages SET deleted_at = now() WHERE id = $1 RETURNING id', [ids.derived]);- expect({ softDelete: spied(softDelete) ? softDelete : 'ok' }).toEqual({ softDelete: 'ok' });- const page = failure(await run(`INSERT INTO pages (slug, type, title, compiled_truth, content_hash) VALUES ('notes/again-example', 'note', 't', 'x', $1)`, [PURGED_HASH]));- expect(page.message).toStartWith('purged_content:');- const fact = failure(await run(`INSERT INTO facts (fact, source) VALUES ($1, 'probe')`, [PURGED_CLAIM]));- expect(fact.message).toStartWith('purged_content:');- const [held, heldOutput] = insertDerivation(JSON.stringify({ text: PURGED_CLAIM }));- const derivation = failure(await run(held, [ids.takes, 3, heldOutput]));- expect(derivation.message).toStartWith('derivation_purge_pending:');- });- } finally {- await conn.unsafe(`REVOKE CREATE ON SCHEMA public FROM ${WRITER}`);- }- });-- test('19. while a purge holds a source, a role RLS refuses gets the same 42501 inserting a fact into it as into a source that does not exist', async () => {- const holder = postgres(url, { max: 1, prepare: false, onnotice: () => {} });- const session = await holder.reserve();- try {- await session.unsafe(`BEGIN; SELECT id FROM sources WHERE id = 'default' FOR UPDATE`);- for (const role of API_ROLES) {- await as(conn, role, async run => {- rowsOf(await run(`SET LOCAL lock_timeout = '1s'`));- const insert = (source: string) => run(`INSERT INTO facts (fact, source, source_id) VALUES ('an unrelated claim', 'probe', $1)`, [source]);- const locked = failure(await insert('default'));- expect({ role, locked }).toEqual({ role, locked: failure(await insert('no-such-source-example')) });- expect(locked.code).toBe('42501');- });- }- } finally {- await session.unsafe('ROLLBACK').catch(() => {});- session.release();- await holder.end();- }- });-- test('20. a purged take claim is refused for the owner on insert and update, and for a writer that cannot read take_purges on update', async () => {- const [{ owner }] = await conn.unsafe<Array<{ owner: string }>>('SELECT current_user AS owner');- for (const role of [owner!, WRITER]) {- await as(conn, role, async run => {- const purged = (o: Outcome) => ({ role, ...failure(o) });- const refusal = { role, code: 'P0001', message: expect.stringContaining('purged_content: this take claim was purged') };- if (role === owner) expect(purged(await run(`INSERT INTO takes (page_id, row_num, claim, kind, holder) VALUES ($1, 7, $2, 'take', 'alice-example')`, [ids.takes, PURGED_TAKE]))).toEqual(refusal);- const [take] = rowsOf(await run(`INSERT INTO takes (page_id, row_num, claim, kind, holder) VALUES ($1, 8, 'an unrelated take', 'take', 'alice-example') RETURNING id`, [ids.takes]));- expect(purged(await run('UPDATE takes SET claim = $1 WHERE id = $2', [PURGED_TAKE, take!.id]))).toEqual(refusal);- });- }- });-});diff --git a/test/e2e/rls-every-table-postgres.test.ts b/test/e2e/rls-every-table-postgres.test.tsindex c79e9759a6..3406d53b4f 100644--- a/test/e2e/rls-every-table-postgres.test.ts+++ b/test/e2e/rls-every-table-postgres.test.ts@@ -122,7 +122,6 @@ describeE2E('RLS on every public table (Postgres, no auto-RLS event trigger)', (DROP TRIGGER IF EXISTS pages_derivation_scope_delete ON pages;DROP FUNCTION IF EXISTS gbrain_mark_derivation_scope_entry();DROP FUNCTION IF EXISTS gbrain_refuse_purging_derivation();- DROP FUNCTION IF EXISTS gbrain_refuse_stored_purging_derivation();ALTER TABLE facts DROP CONSTRAINT IF EXISTS facts_source_window_chk, DROP COLUMN IF EXISTS source_window;ALTER TABLE pages DROP COLUMN IF EXISTS withheld_source_path;`);await conn.unsafe(`UPDATE config SET value = '272' WHERE key = 'version'`);diff --git a/test/fact-fingerprint-search-path.test.ts b/test/fact-fingerprint-search-path.test.tsindex fad93a1b89..ed27b62401 100644--- a/test/fact-fingerprint-search-path.test.ts+++ b/test/fact-fingerprint-search-path.test.ts@@ -18,7 +18,6 @@ import type { BrainEngine } from '../src/core/engine.ts';import { PGLiteEngine } from '../src/core/pglite-engine.ts';import { MIGRATIONS, runMigrations } from '../src/core/migrate.ts';import { FACT_WITHDRAWAL_SCHEMA_STATEMENTS } from '../src/core/facts/withdrawal-schema.ts';-import { GUARD_SEARCH_PATH } from '../src/core/guard-definer.ts';import { isolatedPersistencePostgres } from './helpers/persistence-postgres.ts';import { testBackends } from './helpers/test-backends.ts';@@ -74,7 +73,7 @@ for (const kind of testBackends()) {const unpinned = () => engine.executeRaw<{ sig: string }>(`SELECT p.oid::regprocedure::text AS sig FROM pg_proc pJOIN pg_namespace n ON n.oid = p.pronamespace JOIN pg_language l ON l.oid = p.prolangWHERE n.nspname = 'public' AND l.lanname = 'plpgsql' AND p.proname LIKE 'gbrain\\_%'- AND NOT (COALESCE(p.proconfig, '{}'::text[]) && ARRAY['search_path=pg_catalog, public', 'search_path=pg_catalog, public, pg_temp', 'search_path=${GUARD_SEARCH_PATH}'])`);+ AND NOT (COALESCE(p.proconfig, '{}'::text[]) && ARRAY['search_path=pg_catalog, public', 'search_path=pg_catalog, public, pg_temp'])`);const searchPathMigration = MIGRATIONS.find(m => m.name.endsWith('function_search_path'))!;const rerunSearchPathMigration = async () => {expect(searchPathMigration).toBeDefined();diff --git a/test/fixtures/goldens/catalog/pglite-engine-init-default.json b/test/fixtures/goldens/catalog/pglite-engine-init-default.jsonindex 31b24abf34..aa5273e6d1 100644--- a/test/fixtures/goldens/catalog/pglite-engine-init-default.json+++ b/test/fixtures/goldens/catalog/pglite-engine-init-default.json@@ -557,16 +557,13 @@"gbrain_guard_request_protocol()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=12baf1d365a8aa3009ac0fe6605497e6433304e8d5915a3fc0b0b39ad748f6c2","gbrain_guard_skill_publication()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=e854c0d058e75a65c3a90127c5c417380975100e83fc34288f6085e786df10a9","gbrain_lease_shared_skill_delivery()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=5e493c1ac8dce8cb025a736629e563437c4b214744137c302c532c20bf7e7acf",- "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4f2d679df92779f6941e2378b82d5a9d5fb5cb4fe8d571f4d69801e6f646bde6",+ "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=72ac0027fd37ecc4c72ad2e294ae3a98564736339b9ac917ea5d4112ec3cd35f","gbrain_preserve_fact_withdrawal()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=9beb118551a08451a228146373f50f2aa2ce0cfe89937e937d361b33224aa0aa","gbrain_queue_page_projection()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=6c544b9c129b6a17dcabeb5ee8d44a2b0e0af9d02ca3fe47c7d7f22ec313042c",- "gbrain_refuse_purged_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=08d7e84882d373c36a1db161eb9eed1da80ceb5d4373f65abc86f4e87e11a54f",- "gbrain_refuse_purged_page()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=9b08c031113955862b3bcd9f969c8ba721f7fe5c42aaa9992935fc4e7dd6e5ed",- "gbrain_refuse_purged_take()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=875112f8a4a7c22e349f0230c6bf5fd73331c3c54e542c3eaa896d3c21c868a3",- "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=05de18ee0111c91b4db21f46b6e99b20769ca0d69ec405ad6b48506dc23bbad6",- "gbrain_refuse_revived_withdrawn_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=7a383cc3e5c2742020f138aa962696f0e07d76f981295de0c38294a0c33f94ec",- "gbrain_refuse_stored_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4a3444d23904f780bb53285e3abc3ce1b079b27bf3faee2ef60b2915ad672146",- "gbrain_refuse_unguarded_inserted_facts()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=84360ce2ecf76f1dc9aaa00f5e7518531387e4a4bd53285f9ea617b27172bae5",+ "gbrain_refuse_purged_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=d1d584b91ceea7f4e63c235b790ef89c958c578e635f77ddd644918bc36d33f1",+ "gbrain_refuse_purged_page()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=8aaaf7c22fc9acb4b1e84fe75f11ae6c889949b78de1ef6bdba1db54ef43844e",+ "gbrain_refuse_purged_take()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=4a291b0448ab7a31926aa482b5222e0595d31a6bfad81b851b13e4bf581a0d83",+ "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=0d0afb3e61857f1668f2e7996da1c6aaf269aecaa1bf3763ce90df90e2d66fd3","gbrain_require_managed_writer()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=ae9883e69ac3121bc07689f68518c1d97a02a2788a64e496a26f12720300fe8a","gbrain_require_persistence_protocol(required integer)": "RETURNS void kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=af07b7fac60dec0a4fe568217931ac449d32f73b3a53a047b3b02a5f59cb5058","gbrain_snapshot_version_trust()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=7452350236ed4c68a6cd1f4d78a1381a4ef44cc70e8a032141f01bba4a704702",@@ -4314,9 +4311,7 @@"facts.facts_guard_inserted": "CREATE TRIGGER facts_guard_inserted AFTER INSERT ON public.facts REFERENCING NEW TABLE AS inserted_facts FOR EACH STATEMENT EXECUTE FUNCTION gbrain_guard_inserted_facts()","facts.facts_preserve_withdrawal": "CREATE TRIGGER facts_preserve_withdrawal BEFORE UPDATE OF fact, source_id, visibility, entity_slug, expired_at ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_preserve_fact_withdrawal()","facts.facts_preserve_withdrawal_insert": "CREATE TRIGGER facts_preserve_withdrawal_insert BEFORE INSERT ON public.facts FOR EACH ROW WHEN (((new.expired_at IS NULL) AND (COALESCE(current_setting('gbrain.fact_withdrawal_stamp_deferred'::text, true), ''::text) <> 'on'::text))) EXECUTE FUNCTION gbrain_preserve_fact_withdrawal()",- "facts.facts_refuse_purged": "CREATE TRIGGER facts_refuse_purged AFTER UPDATE OF fact, source_id, visibility, entity_slug ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_fact()",- "facts.facts_refuse_revived_withdrawal": "CREATE TRIGGER facts_refuse_revived_withdrawal AFTER UPDATE OF fact, source_id, visibility, entity_slug, expired_at ON public.facts FOR EACH ROW WHEN ((new.expired_at IS NULL)) EXECUTE FUNCTION gbrain_refuse_revived_withdrawn_fact()",- "facts.facts_refuse_unguarded_inserted": "CREATE TRIGGER facts_refuse_unguarded_inserted AFTER INSERT ON public.facts REFERENCING NEW TABLE AS inserted_facts FOR EACH STATEMENT EXECUTE FUNCTION gbrain_refuse_unguarded_inserted_facts()",+ "facts.facts_refuse_purged": "CREATE TRIGGER facts_refuse_purged BEFORE UPDATE OF fact, source_id, visibility, entity_slug ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_fact()","facts.gbrain_write_attribution": "CREATE TRIGGER gbrain_write_attribution BEFORE INSERT OR UPDATE ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_write_attribution()","facts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","facts.planner_stats_del": "CREATE TRIGGER planner_stats_del AFTER DELETE ON public.facts REFERENCING OLD TABLE AS old_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()",@@ -4336,7 +4331,6 @@"page_body_manifest.page_body_manifest_derivation_scope_retire": "CREATE TRIGGER page_body_manifest_derivation_scope_retire AFTER UPDATE OF gen_to ON public.page_body_manifest FOR EACH ROW WHEN (((old.gen_to IS NULL) AND (new.gen_to IS NOT NULL) AND (old.staging_id IS NULL))) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry()","page_purges.trust_generation_insert": "CREATE CONSTRAINT TRIGGER trust_generation_insert AFTER INSERT ON public.page_purges DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN (true) EXECUTE FUNCTION gbrain_bump_trust_generation()","page_segment_derivations.page_segment_derivations_refuse_purging": "CREATE TRIGGER page_segment_derivations_refuse_purging BEFORE INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purging_derivation()",- "page_segment_derivations.page_segment_derivations_refuse_stored_purging": "CREATE TRIGGER page_segment_derivations_refuse_stored_purging AFTER INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_stored_purging_derivation()","page_segment_texts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.page_segment_texts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","page_versions.page_versions_trust_snapshot": "CREATE TRIGGER page_versions_trust_snapshot BEFORE INSERT ON public.page_versions FOR EACH ROW EXECUTE FUNCTION gbrain_snapshot_version_trust()","page_versions.page_versions_write_attribution": "CREATE TRIGGER page_versions_write_attribution BEFORE INSERT ON public.page_versions FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_version_attribution()",@@ -4348,7 +4342,7 @@"pages.pages_forget_retrievals": "CREATE TRIGGER pages_forget_retrievals AFTER DELETE ON public.pages REFERENCING OLD TABLE AS gbrain_deleted_pages FOR EACH STATEMENT EXECUTE FUNCTION gbrain_forget_page_retrievals()","pages.pages_knowledge_revision": "CREATE TRIGGER pages_knowledge_revision BEFORE UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_advance_page_revision()","pages.pages_projection_queue": "CREATE TRIGGER pages_projection_queue AFTER INSERT OR DELETE OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_queue_page_projection()",- "pages.pages_refuse_purged": "CREATE TRIGGER pages_refuse_purged AFTER INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_page()",+ "pages.pages_refuse_purged": "CREATE TRIGGER pages_refuse_purged BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_page()","pages.pages_revision_attribution": "CREATE TRIGGER pages_revision_attribution BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_revision_attribution()","pages.planner_stats_del": "CREATE TRIGGER planner_stats_del AFTER DELETE ON public.pages REFERENCING OLD TABLE AS old_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()","pages.planner_stats_ins": "CREATE TRIGGER planner_stats_ins AFTER INSERT ON public.pages REFERENCING NEW TABLE AS new_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()",@@ -4378,7 +4372,7 @@"takes.planner_stats_del": "CREATE TRIGGER planner_stats_del AFTER DELETE ON public.takes REFERENCING OLD TABLE AS old_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()","takes.planner_stats_ins": "CREATE TRIGGER planner_stats_ins AFTER INSERT ON public.takes REFERENCING NEW TABLE AS new_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()","takes.planner_stats_upd": "CREATE TRIGGER planner_stats_upd AFTER UPDATE ON public.takes REFERENCING NEW TABLE AS new_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()",- "takes.takes_refuse_purged": "CREATE TRIGGER takes_refuse_purged AFTER INSERT OR UPDATE OF claim, page_id ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_take()",+ "takes.takes_refuse_purged": "CREATE TRIGGER takes_refuse_purged BEFORE INSERT OR UPDATE OF claim, page_id ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_take()","takes.trust_generation_update": "CREATE CONSTRAINT TRIGGER trust_generation_update AFTER UPDATE ON public.takes DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ((old.trust_tier IS DISTINCT FROM new.trust_tier)) EXECUTE FUNCTION gbrain_bump_trust_generation()","takes.trust_tier_stamp": "CREATE TRIGGER trust_tier_stamp BEFORE INSERT OR UPDATE ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_trust_tier()","timeline_entries.gbrain_write_attribution": "CREATE TRIGGER gbrain_write_attribution BEFORE INSERT OR UPDATE ON public.timeline_entries FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_write_attribution()",diff --git a/test/fixtures/goldens/catalog/pglite-engine-init-fts-portuguese.json b/test/fixtures/goldens/catalog/pglite-engine-init-fts-portuguese.jsonindex 64aa8622b6..4b036a54cc 100644--- a/test/fixtures/goldens/catalog/pglite-engine-init-fts-portuguese.json+++ b/test/fixtures/goldens/catalog/pglite-engine-init-fts-portuguese.json@@ -557,16 +557,13 @@"gbrain_guard_request_protocol()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=12baf1d365a8aa3009ac0fe6605497e6433304e8d5915a3fc0b0b39ad748f6c2","gbrain_guard_skill_publication()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=e854c0d058e75a65c3a90127c5c417380975100e83fc34288f6085e786df10a9","gbrain_lease_shared_skill_delivery()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=5e493c1ac8dce8cb025a736629e563437c4b214744137c302c532c20bf7e7acf",- "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4f2d679df92779f6941e2378b82d5a9d5fb5cb4fe8d571f4d69801e6f646bde6",+ "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=72ac0027fd37ecc4c72ad2e294ae3a98564736339b9ac917ea5d4112ec3cd35f","gbrain_preserve_fact_withdrawal()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=9beb118551a08451a228146373f50f2aa2ce0cfe89937e937d361b33224aa0aa","gbrain_queue_page_projection()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=6c544b9c129b6a17dcabeb5ee8d44a2b0e0af9d02ca3fe47c7d7f22ec313042c",- "gbrain_refuse_purged_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=08d7e84882d373c36a1db161eb9eed1da80ceb5d4373f65abc86f4e87e11a54f",- "gbrain_refuse_purged_page()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=9b08c031113955862b3bcd9f969c8ba721f7fe5c42aaa9992935fc4e7dd6e5ed",- "gbrain_refuse_purged_take()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=875112f8a4a7c22e349f0230c6bf5fd73331c3c54e542c3eaa896d3c21c868a3",- "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=05de18ee0111c91b4db21f46b6e99b20769ca0d69ec405ad6b48506dc23bbad6",- "gbrain_refuse_revived_withdrawn_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=7a383cc3e5c2742020f138aa962696f0e07d76f981295de0c38294a0c33f94ec",- "gbrain_refuse_stored_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4a3444d23904f780bb53285e3abc3ce1b079b27bf3faee2ef60b2915ad672146",- "gbrain_refuse_unguarded_inserted_facts()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=84360ce2ecf76f1dc9aaa00f5e7518531387e4a4bd53285f9ea617b27172bae5",+ "gbrain_refuse_purged_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=d1d584b91ceea7f4e63c235b790ef89c958c578e635f77ddd644918bc36d33f1",+ "gbrain_refuse_purged_page()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=8aaaf7c22fc9acb4b1e84fe75f11ae6c889949b78de1ef6bdba1db54ef43844e",+ "gbrain_refuse_purged_take()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=4a291b0448ab7a31926aa482b5222e0595d31a6bfad81b851b13e4bf581a0d83",+ "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=0d0afb3e61857f1668f2e7996da1c6aaf269aecaa1bf3763ce90df90e2d66fd3","gbrain_require_managed_writer()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=ae9883e69ac3121bc07689f68518c1d97a02a2788a64e496a26f12720300fe8a","gbrain_require_persistence_protocol(required integer)": "RETURNS void kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=af07b7fac60dec0a4fe568217931ac449d32f73b3a53a047b3b02a5f59cb5058","gbrain_snapshot_version_trust()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=7452350236ed4c68a6cd1f4d78a1381a4ef44cc70e8a032141f01bba4a704702",@@ -4314,9 +4311,7 @@"facts.facts_guard_inserted": "CREATE TRIGGER facts_guard_inserted AFTER INSERT ON public.facts REFERENCING NEW TABLE AS inserted_facts FOR EACH STATEMENT EXECUTE FUNCTION gbrain_guard_inserted_facts()","facts.facts_preserve_withdrawal": "CREATE TRIGGER facts_preserve_withdrawal BEFORE UPDATE OF fact, source_id, visibility, entity_slug, expired_at ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_preserve_fact_withdrawal()","facts.facts_preserve_withdrawal_insert": "CREATE TRIGGER facts_preserve_withdrawal_insert BEFORE INSERT ON public.facts FOR EACH ROW WHEN (((new.expired_at IS NULL) AND (COALESCE(current_setting('gbrain.fact_withdrawal_stamp_deferred'::text, true), ''::text) <> 'on'::text))) EXECUTE FUNCTION gbrain_preserve_fact_withdrawal()",- "facts.facts_refuse_purged": "CREATE TRIGGER facts_refuse_purged AFTER UPDATE OF fact, source_id, visibility, entity_slug ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_fact()",- "facts.facts_refuse_revived_withdrawal": "CREATE TRIGGER facts_refuse_revived_withdrawal AFTER UPDATE OF fact, source_id, visibility, entity_slug, expired_at ON public.facts FOR EACH ROW WHEN ((new.expired_at IS NULL)) EXECUTE FUNCTION gbrain_refuse_revived_withdrawn_fact()",- "facts.facts_refuse_unguarded_inserted": "CREATE TRIGGER facts_refuse_unguarded_inserted AFTER INSERT ON public.facts REFERENCING NEW TABLE AS inserted_facts FOR EACH STATEMENT EXECUTE FUNCTION gbrain_refuse_unguarded_inserted_facts()",+ "facts.facts_refuse_purged": "CREATE TRIGGER facts_refuse_purged BEFORE UPDATE OF fact, source_id, visibility, entity_slug ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_fact()","facts.gbrain_write_attribution": "CREATE TRIGGER gbrain_write_attribution BEFORE INSERT OR UPDATE ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_write_attribution()","facts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","facts.planner_stats_del": "CREATE TRIGGER planner_stats_del AFTER DELETE ON public.facts REFERENCING OLD TABLE AS old_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()",@@ -4336,7 +4331,6 @@"page_body_manifest.page_body_manifest_derivation_scope_retire": "CREATE TRIGGER page_body_manifest_derivation_scope_retire AFTER UPDATE OF gen_to ON public.page_body_manifest FOR EACH ROW WHEN (((old.gen_to IS NULL) AND (new.gen_to IS NOT NULL) AND (old.staging_id IS NULL))) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry()","page_purges.trust_generation_insert": "CREATE CONSTRAINT TRIGGER trust_generation_insert AFTER INSERT ON public.page_purges DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN (true) EXECUTE FUNCTION gbrain_bump_trust_generation()","page_segment_derivations.page_segment_derivations_refuse_purging": "CREATE TRIGGER page_segment_derivations_refuse_purging BEFORE INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purging_derivation()",- "page_segment_derivations.page_segment_derivations_refuse_stored_purging": "CREATE TRIGGER page_segment_derivations_refuse_stored_purging AFTER INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_stored_purging_derivation()","page_segment_texts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.page_segment_texts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","page_versions.page_versions_trust_snapshot": "CREATE TRIGGER page_versions_trust_snapshot BEFORE INSERT ON public.page_versions FOR EACH ROW EXECUTE FUNCTION gbrain_snapshot_version_trust()","page_versions.page_versions_write_attribution": "CREATE TRIGGER page_versions_write_attribution BEFORE INSERT ON public.page_versions FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_version_attribution()",@@ -4348,7 +4342,7 @@"pages.pages_forget_retrievals": "CREATE TRIGGER pages_forget_retrievals AFTER DELETE ON public.pages REFERENCING OLD TABLE AS gbrain_deleted_pages FOR EACH STATEMENT EXECUTE FUNCTION gbrain_forget_page_retrievals()","pages.pages_knowledge_revision": "CREATE TRIGGER pages_knowledge_revision BEFORE UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_advance_page_revision()","pages.pages_projection_queue": "CREATE TRIGGER pages_projection_queue AFTER INSERT OR DELETE OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_queue_page_projection()",- "pages.pages_refuse_purged": "CREATE TRIGGER pages_refuse_purged AFTER INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_page()",+ "pages.pages_refuse_purged": "CREATE TRIGGER pages_refuse_purged BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_page()","pages.pages_revision_attribution": "CREATE TRIGGER pages_revision_attribution BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_revision_attribution()","pages.planner_stats_del": "CREATE TRIGGER planner_stats_del AFTER DELETE ON public.pages REFERENCING OLD TABLE AS old_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()","pages.planner_stats_ins": "CREATE TRIGGER planner_stats_ins AFTER INSERT ON public.pages REFERENCING NEW TABLE AS new_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()",@@ -4378,7 +4372,7 @@"takes.planner_stats_del": "CREATE TRIGGER planner_stats_del AFTER DELETE ON public.takes REFERENCING OLD TABLE AS old_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()","takes.planner_stats_ins": "CREATE TRIGGER planner_stats_ins AFTER INSERT ON public.takes REFERENCING NEW TABLE AS new_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()","takes.planner_stats_upd": "CREATE TRIGGER planner_stats_upd AFTER UPDATE ON public.takes REFERENCING NEW TABLE AS new_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()",- "takes.takes_refuse_purged": "CREATE TRIGGER takes_refuse_purged AFTER INSERT OR UPDATE OF claim, page_id ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_take()",+ "takes.takes_refuse_purged": "CREATE TRIGGER takes_refuse_purged BEFORE INSERT OR UPDATE OF claim, page_id ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_take()","takes.trust_generation_update": "CREATE CONSTRAINT TRIGGER trust_generation_update AFTER UPDATE ON public.takes DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ((old.trust_tier IS DISTINCT FROM new.trust_tier)) EXECUTE FUNCTION gbrain_bump_trust_generation()","takes.trust_tier_stamp": "CREATE TRIGGER trust_tier_stamp BEFORE INSERT OR UPDATE ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_trust_tier()","timeline_entries.gbrain_write_attribution": "CREATE TRIGGER gbrain_write_attribution BEFORE INSERT OR UPDATE ON public.timeline_entries FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_write_attribution()",diff --git a/test/fixtures/goldens/catalog/pglite-engine-init-high-dims.json b/test/fixtures/goldens/catalog/pglite-engine-init-high-dims.jsonindex 642dc33bce..1759420721 100644--- a/test/fixtures/goldens/catalog/pglite-engine-init-high-dims.json+++ b/test/fixtures/goldens/catalog/pglite-engine-init-high-dims.json@@ -557,16 +557,13 @@"gbrain_guard_request_protocol()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=12baf1d365a8aa3009ac0fe6605497e6433304e8d5915a3fc0b0b39ad748f6c2","gbrain_guard_skill_publication()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=e854c0d058e75a65c3a90127c5c417380975100e83fc34288f6085e786df10a9","gbrain_lease_shared_skill_delivery()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=5e493c1ac8dce8cb025a736629e563437c4b214744137c302c532c20bf7e7acf",- "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4f2d679df92779f6941e2378b82d5a9d5fb5cb4fe8d571f4d69801e6f646bde6",+ "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=72ac0027fd37ecc4c72ad2e294ae3a98564736339b9ac917ea5d4112ec3cd35f","gbrain_preserve_fact_withdrawal()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=9beb118551a08451a228146373f50f2aa2ce0cfe89937e937d361b33224aa0aa","gbrain_queue_page_projection()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=6c544b9c129b6a17dcabeb5ee8d44a2b0e0af9d02ca3fe47c7d7f22ec313042c",- "gbrain_refuse_purged_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=08d7e84882d373c36a1db161eb9eed1da80ceb5d4373f65abc86f4e87e11a54f",- "gbrain_refuse_purged_page()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=9b08c031113955862b3bcd9f969c8ba721f7fe5c42aaa9992935fc4e7dd6e5ed",- "gbrain_refuse_purged_take()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=875112f8a4a7c22e349f0230c6bf5fd73331c3c54e542c3eaa896d3c21c868a3",- "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=05de18ee0111c91b4db21f46b6e99b20769ca0d69ec405ad6b48506dc23bbad6",- "gbrain_refuse_revived_withdrawn_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=7a383cc3e5c2742020f138aa962696f0e07d76f981295de0c38294a0c33f94ec",- "gbrain_refuse_stored_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4a3444d23904f780bb53285e3abc3ce1b079b27bf3faee2ef60b2915ad672146",- "gbrain_refuse_unguarded_inserted_facts()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=84360ce2ecf76f1dc9aaa00f5e7518531387e4a4bd53285f9ea617b27172bae5",+ "gbrain_refuse_purged_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=d1d584b91ceea7f4e63c235b790ef89c958c578e635f77ddd644918bc36d33f1",+ "gbrain_refuse_purged_page()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=8aaaf7c22fc9acb4b1e84fe75f11ae6c889949b78de1ef6bdba1db54ef43844e",+ "gbrain_refuse_purged_take()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=4a291b0448ab7a31926aa482b5222e0595d31a6bfad81b851b13e4bf581a0d83",+ "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=0d0afb3e61857f1668f2e7996da1c6aaf269aecaa1bf3763ce90df90e2d66fd3","gbrain_require_managed_writer()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=ae9883e69ac3121bc07689f68518c1d97a02a2788a64e496a26f12720300fe8a","gbrain_require_persistence_protocol(required integer)": "RETURNS void kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=af07b7fac60dec0a4fe568217931ac449d32f73b3a53a047b3b02a5f59cb5058","gbrain_snapshot_version_trust()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=7452350236ed4c68a6cd1f4d78a1381a4ef44cc70e8a032141f01bba4a704702",@@ -4310,9 +4307,7 @@"facts.facts_guard_inserted": "CREATE TRIGGER facts_guard_inserted AFTER INSERT ON public.facts REFERENCING NEW TABLE AS inserted_facts FOR EACH STATEMENT EXECUTE FUNCTION gbrain_guard_inserted_facts()","facts.facts_preserve_withdrawal": "CREATE TRIGGER facts_preserve_withdrawal BEFORE UPDATE OF fact, source_id, visibility, entity_slug, expired_at ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_preserve_fact_withdrawal()","facts.facts_preserve_withdrawal_insert": "CREATE TRIGGER facts_preserve_withdrawal_insert BEFORE INSERT ON public.facts FOR EACH ROW WHEN (((new.expired_at IS NULL) AND (COALESCE(current_setting('gbrain.fact_withdrawal_stamp_deferred'::text, true), ''::text) <> 'on'::text))) EXECUTE FUNCTION gbrain_preserve_fact_withdrawal()",- "facts.facts_refuse_purged": "CREATE TRIGGER facts_refuse_purged AFTER UPDATE OF fact, source_id, visibility, entity_slug ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_fact()",- "facts.facts_refuse_revived_withdrawal": "CREATE TRIGGER facts_refuse_revived_withdrawal AFTER UPDATE OF fact, source_id, visibility, entity_slug, expired_at ON public.facts FOR EACH ROW WHEN ((new.expired_at IS NULL)) EXECUTE FUNCTION gbrain_refuse_revived_withdrawn_fact()",- "facts.facts_refuse_unguarded_inserted": "CREATE TRIGGER facts_refuse_unguarded_inserted AFTER INSERT ON public.facts REFERENCING NEW TABLE AS inserted_facts FOR EACH STATEMENT EXECUTE FUNCTION gbrain_refuse_unguarded_inserted_facts()",+ "facts.facts_refuse_purged": "CREATE TRIGGER facts_refuse_purged BEFORE UPDATE OF fact, source_id, visibility, entity_slug ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_fact()","facts.gbrain_write_attribution": "CREATE TRIGGER gbrain_write_attribution BEFORE INSERT OR UPDATE ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_write_attribution()","facts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","facts.planner_stats_del": "CREATE TRIGGER planner_stats_del AFTER DELETE ON public.facts REFERENCING OLD TABLE AS old_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()",@@ -4332,7 +4327,6 @@"page_body_manifest.page_body_manifest_derivation_scope_retire": "CREATE TRIGGER page_body_manifest_derivation_scope_retire AFTER UPDATE OF gen_to ON public.page_body_manifest FOR EACH ROW WHEN (((old.gen_to IS NULL) AND (new.gen_to IS NOT NULL) AND (old.staging_id IS NULL))) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry()","page_purges.trust_generation_insert": "CREATE CONSTRAINT TRIGGER trust_generation_insert AFTER INSERT ON public.page_purges DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN (true) EXECUTE FUNCTION gbrain_bump_trust_generation()","page_segment_derivations.page_segment_derivations_refuse_purging": "CREATE TRIGGER page_segment_derivations_refuse_purging BEFORE INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purging_derivation()",- "page_segment_derivations.page_segment_derivations_refuse_stored_purging": "CREATE TRIGGER page_segment_derivations_refuse_stored_purging AFTER INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_stored_purging_derivation()","page_segment_texts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.page_segment_texts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","page_versions.page_versions_trust_snapshot": "CREATE TRIGGER page_versions_trust_snapshot BEFORE INSERT ON public.page_versions FOR EACH ROW EXECUTE FUNCTION gbrain_snapshot_version_trust()","page_versions.page_versions_write_attribution": "CREATE TRIGGER page_versions_write_attribution BEFORE INSERT ON public.page_versions FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_version_attribution()",@@ -4344,7 +4338,7 @@"pages.pages_forget_retrievals": "CREATE TRIGGER pages_forget_retrievals AFTER DELETE ON public.pages REFERENCING OLD TABLE AS gbrain_deleted_pages FOR EACH STATEMENT EXECUTE FUNCTION gbrain_forget_page_retrievals()","pages.pages_knowledge_revision": "CREATE TRIGGER pages_knowledge_revision BEFORE UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_advance_page_revision()","pages.pages_projection_queue": "CREATE TRIGGER pages_projection_queue AFTER INSERT OR DELETE OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_queue_page_projection()",- "pages.pages_refuse_purged": "CREATE TRIGGER pages_refuse_purged AFTER INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_page()",+ "pages.pages_refuse_purged": "CREATE TRIGGER pages_refuse_purged BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_page()","pages.pages_revision_attribution": "CREATE TRIGGER pages_revision_attribution BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_revision_attribution()","pages.planner_stats_del": "CREATE TRIGGER planner_stats_del AFTER DELETE ON public.pages REFERENCING OLD TABLE AS old_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()","pages.planner_stats_ins": "CREATE TRIGGER planner_stats_ins AFTER INSERT ON public.pages REFERENCING NEW TABLE AS new_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()",@@ -4374,7 +4368,7 @@"takes.planner_stats_del": "CREATE TRIGGER planner_stats_del AFTER DELETE ON public.takes REFERENCING OLD TABLE AS old_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()","takes.planner_stats_ins": "CREATE TRIGGER planner_stats_ins AFTER INSERT ON public.takes REFERENCING NEW TABLE AS new_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()","takes.planner_stats_upd": "CREATE TRIGGER planner_stats_upd AFTER UPDATE ON public.takes REFERENCING NEW TABLE AS new_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()",- "takes.takes_refuse_purged": "CREATE TRIGGER takes_refuse_purged AFTER INSERT OR UPDATE OF claim, page_id ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_take()",+ "takes.takes_refuse_purged": "CREATE TRIGGER takes_refuse_purged BEFORE INSERT OR UPDATE OF claim, page_id ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_take()","takes.trust_generation_update": "CREATE CONSTRAINT TRIGGER trust_generation_update AFTER UPDATE ON public.takes DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ((old.trust_tier IS DISTINCT FROM new.trust_tier)) EXECUTE FUNCTION gbrain_bump_trust_generation()","takes.trust_tier_stamp": "CREATE TRIGGER trust_tier_stamp BEFORE INSERT OR UPDATE ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_trust_tier()","timeline_entries.gbrain_write_attribution": "CREATE TRIGGER gbrain_write_attribution BEFORE INSERT OR UPDATE ON public.timeline_entries FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_write_attribution()",diff --git a/test/fixtures/goldens/catalog/pglite-schema-blob-default.json b/test/fixtures/goldens/catalog/pglite-schema-blob-default.jsonindex 2565d520d0..734de62aee 100644--- a/test/fixtures/goldens/catalog/pglite-schema-blob-default.json+++ b/test/fixtures/goldens/catalog/pglite-schema-blob-default.json@@ -419,10 +419,9 @@"gbrain_guard_request_protocol()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=12baf1d365a8aa3009ac0fe6605497e6433304e8d5915a3fc0b0b39ad748f6c2","gbrain_guard_skill_publication()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=e854c0d058e75a65c3a90127c5c417380975100e83fc34288f6085e786df10a9","gbrain_lease_shared_skill_delivery()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=5e493c1ac8dce8cb025a736629e563437c4b214744137c302c532c20bf7e7acf",- "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4f2d679df92779f6941e2378b82d5a9d5fb5cb4fe8d571f4d69801e6f646bde6",+ "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=72ac0027fd37ecc4c72ad2e294ae3a98564736339b9ac917ea5d4112ec3cd35f","gbrain_queue_page_projection()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=6c544b9c129b6a17dcabeb5ee8d44a2b0e0af9d02ca3fe47c7d7f22ec313042c",- "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=05de18ee0111c91b4db21f46b6e99b20769ca0d69ec405ad6b48506dc23bbad6",- "gbrain_refuse_stored_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4a3444d23904f780bb53285e3abc3ce1b079b27bf3faee2ef60b2915ad672146",+ "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=0d0afb3e61857f1668f2e7996da1c6aaf269aecaa1bf3763ce90df90e2d66fd3","gbrain_require_managed_writer()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=ae9883e69ac3121bc07689f68518c1d97a02a2788a64e496a26f12720300fe8a","gbrain_require_persistence_protocol(required integer)": "RETURNS void kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=af07b7fac60dec0a4fe568217931ac449d32f73b3a53a047b3b02a5f59cb5058","gbrain_try_jsonb(input text)": "RETURNS jsonb kind=f lang=plpgsql volatility=i secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=11b96a0400158fcb3dbd84255985cd11e473688c53fff64ebf92602fceccbedf",@@ -3294,7 +3293,6 @@"page_body_manifest.page_body_manifest_derivation_scope_delete": "CREATE TRIGGER page_body_manifest_derivation_scope_delete AFTER DELETE ON public.page_body_manifest FOR EACH ROW WHEN (((old.gen_to IS NULL) AND (old.staging_id IS NULL))) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry()","page_body_manifest.page_body_manifest_derivation_scope_retire": "CREATE TRIGGER page_body_manifest_derivation_scope_retire AFTER UPDATE OF gen_to ON public.page_body_manifest FOR EACH ROW WHEN (((old.gen_to IS NULL) AND (new.gen_to IS NOT NULL) AND (old.staging_id IS NULL))) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry()","page_segment_derivations.page_segment_derivations_refuse_purging": "CREATE TRIGGER page_segment_derivations_refuse_purging BEFORE INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purging_derivation()",- "page_segment_derivations.page_segment_derivations_refuse_stored_purging": "CREATE TRIGGER page_segment_derivations_refuse_stored_purging AFTER INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_stored_purging_derivation()","page_segment_texts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.page_segment_texts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","pages.bump_page_generation_clock_trg": "CREATE TRIGGER bump_page_generation_clock_trg AFTER INSERT OR DELETE OR UPDATE ON public.pages FOR EACH STATEMENT EXECUTE FUNCTION bump_page_generation_clock_fn()","pages.bump_page_generation_trg": "CREATE TRIGGER bump_page_generation_trg BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION bump_page_generation_fn()",diff --git a/test/fixtures/goldens/catalog/pglite-schema-blob-fts-portuguese.json b/test/fixtures/goldens/catalog/pglite-schema-blob-fts-portuguese.jsonindex a6a0d75487..2d974cc29b 100644--- a/test/fixtures/goldens/catalog/pglite-schema-blob-fts-portuguese.json+++ b/test/fixtures/goldens/catalog/pglite-schema-blob-fts-portuguese.json@@ -419,10 +419,9 @@"gbrain_guard_request_protocol()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=12baf1d365a8aa3009ac0fe6605497e6433304e8d5915a3fc0b0b39ad748f6c2","gbrain_guard_skill_publication()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=e854c0d058e75a65c3a90127c5c417380975100e83fc34288f6085e786df10a9","gbrain_lease_shared_skill_delivery()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=5e493c1ac8dce8cb025a736629e563437c4b214744137c302c532c20bf7e7acf",- "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4f2d679df92779f6941e2378b82d5a9d5fb5cb4fe8d571f4d69801e6f646bde6",+ "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=72ac0027fd37ecc4c72ad2e294ae3a98564736339b9ac917ea5d4112ec3cd35f","gbrain_queue_page_projection()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=6c544b9c129b6a17dcabeb5ee8d44a2b0e0af9d02ca3fe47c7d7f22ec313042c",- "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=05de18ee0111c91b4db21f46b6e99b20769ca0d69ec405ad6b48506dc23bbad6",- "gbrain_refuse_stored_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4a3444d23904f780bb53285e3abc3ce1b079b27bf3faee2ef60b2915ad672146",+ "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=0d0afb3e61857f1668f2e7996da1c6aaf269aecaa1bf3763ce90df90e2d66fd3","gbrain_require_managed_writer()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=ae9883e69ac3121bc07689f68518c1d97a02a2788a64e496a26f12720300fe8a","gbrain_require_persistence_protocol(required integer)": "RETURNS void kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=af07b7fac60dec0a4fe568217931ac449d32f73b3a53a047b3b02a5f59cb5058","gbrain_try_jsonb(input text)": "RETURNS jsonb kind=f lang=plpgsql volatility=i secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=11b96a0400158fcb3dbd84255985cd11e473688c53fff64ebf92602fceccbedf",@@ -3294,7 +3293,6 @@"page_body_manifest.page_body_manifest_derivation_scope_delete": "CREATE TRIGGER page_body_manifest_derivation_scope_delete AFTER DELETE ON public.page_body_manifest FOR EACH ROW WHEN (((old.gen_to IS NULL) AND (old.staging_id IS NULL))) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry()","page_body_manifest.page_body_manifest_derivation_scope_retire": "CREATE TRIGGER page_body_manifest_derivation_scope_retire AFTER UPDATE OF gen_to ON public.page_body_manifest FOR EACH ROW WHEN (((old.gen_to IS NULL) AND (new.gen_to IS NOT NULL) AND (old.staging_id IS NULL))) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry()","page_segment_derivations.page_segment_derivations_refuse_purging": "CREATE TRIGGER page_segment_derivations_refuse_purging BEFORE INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purging_derivation()",- "page_segment_derivations.page_segment_derivations_refuse_stored_purging": "CREATE TRIGGER page_segment_derivations_refuse_stored_purging AFTER INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_stored_purging_derivation()","page_segment_texts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.page_segment_texts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","pages.bump_page_generation_clock_trg": "CREATE TRIGGER bump_page_generation_clock_trg AFTER INSERT OR DELETE OR UPDATE ON public.pages FOR EACH STATEMENT EXECUTE FUNCTION bump_page_generation_clock_fn()","pages.bump_page_generation_trg": "CREATE TRIGGER bump_page_generation_trg BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION bump_page_generation_fn()",diff --git a/test/fixtures/goldens/catalog/pglite-schema-blob-high-dims.json b/test/fixtures/goldens/catalog/pglite-schema-blob-high-dims.jsonindex bb0d94abbb..2e73118eaf 100644--- a/test/fixtures/goldens/catalog/pglite-schema-blob-high-dims.json+++ b/test/fixtures/goldens/catalog/pglite-schema-blob-high-dims.json@@ -419,10 +419,9 @@"gbrain_guard_request_protocol()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=12baf1d365a8aa3009ac0fe6605497e6433304e8d5915a3fc0b0b39ad748f6c2","gbrain_guard_skill_publication()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=e854c0d058e75a65c3a90127c5c417380975100e83fc34288f6085e786df10a9","gbrain_lease_shared_skill_delivery()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=5e493c1ac8dce8cb025a736629e563437c4b214744137c302c532c20bf7e7acf",- "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4f2d679df92779f6941e2378b82d5a9d5fb5cb4fe8d571f4d69801e6f646bde6",+ "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=72ac0027fd37ecc4c72ad2e294ae3a98564736339b9ac917ea5d4112ec3cd35f","gbrain_queue_page_projection()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=6c544b9c129b6a17dcabeb5ee8d44a2b0e0af9d02ca3fe47c7d7f22ec313042c",- "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=05de18ee0111c91b4db21f46b6e99b20769ca0d69ec405ad6b48506dc23bbad6",- "gbrain_refuse_stored_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4a3444d23904f780bb53285e3abc3ce1b079b27bf3faee2ef60b2915ad672146",+ "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=0d0afb3e61857f1668f2e7996da1c6aaf269aecaa1bf3763ce90df90e2d66fd3","gbrain_require_managed_writer()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=ae9883e69ac3121bc07689f68518c1d97a02a2788a64e496a26f12720300fe8a","gbrain_require_persistence_protocol(required integer)": "RETURNS void kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=af07b7fac60dec0a4fe568217931ac449d32f73b3a53a047b3b02a5f59cb5058","gbrain_try_jsonb(input text)": "RETURNS jsonb kind=f lang=plpgsql volatility=i secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=11b96a0400158fcb3dbd84255985cd11e473688c53fff64ebf92602fceccbedf",@@ -3293,7 +3292,6 @@"page_body_manifest.page_body_manifest_derivation_scope_delete": "CREATE TRIGGER page_body_manifest_derivation_scope_delete AFTER DELETE ON public.page_body_manifest FOR EACH ROW WHEN (((old.gen_to IS NULL) AND (old.staging_id IS NULL))) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry()","page_body_manifest.page_body_manifest_derivation_scope_retire": "CREATE TRIGGER page_body_manifest_derivation_scope_retire AFTER UPDATE OF gen_to ON public.page_body_manifest FOR EACH ROW WHEN (((old.gen_to IS NULL) AND (new.gen_to IS NOT NULL) AND (old.staging_id IS NULL))) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry()","page_segment_derivations.page_segment_derivations_refuse_purging": "CREATE TRIGGER page_segment_derivations_refuse_purging BEFORE INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purging_derivation()",- "page_segment_derivations.page_segment_derivations_refuse_stored_purging": "CREATE TRIGGER page_segment_derivations_refuse_stored_purging AFTER INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_stored_purging_derivation()","page_segment_texts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.page_segment_texts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","pages.bump_page_generation_clock_trg": "CREATE TRIGGER bump_page_generation_clock_trg AFTER INSERT OR DELETE OR UPDATE ON public.pages FOR EACH STATEMENT EXECUTE FUNCTION bump_page_generation_clock_fn()","pages.bump_page_generation_trg": "CREATE TRIGGER bump_page_generation_trg BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION bump_page_generation_fn()",diff --git a/test/fixtures/goldens/catalog/postgres-db-initschema.json b/test/fixtures/goldens/catalog/postgres-db-initschema.jsonindex 7bd7e010cc..c2c93bb232 100644--- a/test/fixtures/goldens/catalog/postgres-db-initschema.json+++ b/test/fixtures/goldens/catalog/postgres-db-initschema.json@@ -428,10 +428,9 @@"gbrain_guard_request_protocol()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=12baf1d365a8aa3009ac0fe6605497e6433304e8d5915a3fc0b0b39ad748f6c2","gbrain_guard_skill_publication()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=e854c0d058e75a65c3a90127c5c417380975100e83fc34288f6085e786df10a9","gbrain_lease_shared_skill_delivery()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=5e493c1ac8dce8cb025a736629e563437c4b214744137c302c532c20bf7e7acf",- "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4f2d679df92779f6941e2378b82d5a9d5fb5cb4fe8d571f4d69801e6f646bde6",+ "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=72ac0027fd37ecc4c72ad2e294ae3a98564736339b9ac917ea5d4112ec3cd35f","gbrain_queue_page_projection()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=6c544b9c129b6a17dcabeb5ee8d44a2b0e0af9d02ca3fe47c7d7f22ec313042c",- "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=05de18ee0111c91b4db21f46b6e99b20769ca0d69ec405ad6b48506dc23bbad6",- "gbrain_refuse_stored_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4a3444d23904f780bb53285e3abc3ce1b079b27bf3faee2ef60b2915ad672146",+ "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=0d0afb3e61857f1668f2e7996da1c6aaf269aecaa1bf3763ce90df90e2d66fd3","gbrain_require_managed_writer()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=ae9883e69ac3121bc07689f68518c1d97a02a2788a64e496a26f12720300fe8a","gbrain_require_persistence_protocol(required integer)": "RETURNS void kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=af07b7fac60dec0a4fe568217931ac449d32f73b3a53a047b3b02a5f59cb5058","gbrain_try_jsonb(input text)": "RETURNS jsonb kind=f lang=plpgsql volatility=i secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=11b96a0400158fcb3dbd84255985cd11e473688c53fff64ebf92602fceccbedf",@@ -3356,7 +3355,6 @@"page_body_manifest.page_body_manifest_derivation_scope_delete": "CREATE TRIGGER page_body_manifest_derivation_scope_delete AFTER DELETE ON public.page_body_manifest FOR EACH ROW WHEN (((old.gen_to IS NULL) AND (old.staging_id IS NULL))) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry()","page_body_manifest.page_body_manifest_derivation_scope_retire": "CREATE TRIGGER page_body_manifest_derivation_scope_retire AFTER UPDATE OF gen_to ON public.page_body_manifest FOR EACH ROW WHEN (((old.gen_to IS NULL) AND (new.gen_to IS NOT NULL) AND (old.staging_id IS NULL))) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry()","page_segment_derivations.page_segment_derivations_refuse_purging": "CREATE TRIGGER page_segment_derivations_refuse_purging BEFORE INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purging_derivation()",- "page_segment_derivations.page_segment_derivations_refuse_stored_purging": "CREATE TRIGGER page_segment_derivations_refuse_stored_purging AFTER INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_stored_purging_derivation()","page_segment_texts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.page_segment_texts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","pages.bump_page_generation_clock_trg": "CREATE TRIGGER bump_page_generation_clock_trg AFTER INSERT OR DELETE OR UPDATE ON public.pages FOR EACH STATEMENT EXECUTE FUNCTION bump_page_generation_clock_fn()","pages.bump_page_generation_trg": "CREATE TRIGGER bump_page_generation_trg BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION bump_page_generation_fn()",diff --git a/test/fixtures/goldens/catalog/postgres-engine-init-default.json b/test/fixtures/goldens/catalog/postgres-engine-init-default.jsonindex eb1595e357..1e3b70fa65 100644--- a/test/fixtures/goldens/catalog/postgres-engine-init-default.json+++ b/test/fixtures/goldens/catalog/postgres-engine-init-default.json@@ -560,16 +560,13 @@"gbrain_guard_request_protocol()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=12baf1d365a8aa3009ac0fe6605497e6433304e8d5915a3fc0b0b39ad748f6c2","gbrain_guard_skill_publication()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=e854c0d058e75a65c3a90127c5c417380975100e83fc34288f6085e786df10a9","gbrain_lease_shared_skill_delivery()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=5e493c1ac8dce8cb025a736629e563437c4b214744137c302c532c20bf7e7acf",- "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4f2d679df92779f6941e2378b82d5a9d5fb5cb4fe8d571f4d69801e6f646bde6",+ "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=72ac0027fd37ecc4c72ad2e294ae3a98564736339b9ac917ea5d4112ec3cd35f","gbrain_preserve_fact_withdrawal()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=9beb118551a08451a228146373f50f2aa2ce0cfe89937e937d361b33224aa0aa","gbrain_queue_page_projection()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=6c544b9c129b6a17dcabeb5ee8d44a2b0e0af9d02ca3fe47c7d7f22ec313042c",- "gbrain_refuse_purged_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=08d7e84882d373c36a1db161eb9eed1da80ceb5d4373f65abc86f4e87e11a54f",- "gbrain_refuse_purged_page()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=9b08c031113955862b3bcd9f969c8ba721f7fe5c42aaa9992935fc4e7dd6e5ed",- "gbrain_refuse_purged_take()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=875112f8a4a7c22e349f0230c6bf5fd73331c3c54e542c3eaa896d3c21c868a3",- "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=05de18ee0111c91b4db21f46b6e99b20769ca0d69ec405ad6b48506dc23bbad6",- "gbrain_refuse_revived_withdrawn_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=7a383cc3e5c2742020f138aa962696f0e07d76f981295de0c38294a0c33f94ec",- "gbrain_refuse_stored_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4a3444d23904f780bb53285e3abc3ce1b079b27bf3faee2ef60b2915ad672146",- "gbrain_refuse_unguarded_inserted_facts()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=84360ce2ecf76f1dc9aaa00f5e7518531387e4a4bd53285f9ea617b27172bae5",+ "gbrain_refuse_purged_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=d1d584b91ceea7f4e63c235b790ef89c958c578e635f77ddd644918bc36d33f1",+ "gbrain_refuse_purged_page()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=8aaaf7c22fc9acb4b1e84fe75f11ae6c889949b78de1ef6bdba1db54ef43844e",+ "gbrain_refuse_purged_take()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=4a291b0448ab7a31926aa482b5222e0595d31a6bfad81b851b13e4bf581a0d83",+ "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=0d0afb3e61857f1668f2e7996da1c6aaf269aecaa1bf3763ce90df90e2d66fd3","gbrain_require_managed_writer()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=ae9883e69ac3121bc07689f68518c1d97a02a2788a64e496a26f12720300fe8a","gbrain_require_persistence_protocol(required integer)": "RETURNS void kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=af07b7fac60dec0a4fe568217931ac449d32f73b3a53a047b3b02a5f59cb5058","gbrain_snapshot_version_trust()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=7452350236ed4c68a6cd1f4d78a1381a4ef44cc70e8a032141f01bba4a704702",@@ -4306,9 +4303,7 @@"facts.facts_guard_inserted": "CREATE TRIGGER facts_guard_inserted AFTER INSERT ON public.facts REFERENCING NEW TABLE AS inserted_facts FOR EACH STATEMENT EXECUTE FUNCTION gbrain_guard_inserted_facts()","facts.facts_preserve_withdrawal": "CREATE TRIGGER facts_preserve_withdrawal BEFORE UPDATE OF fact, source_id, visibility, entity_slug, expired_at ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_preserve_fact_withdrawal()","facts.facts_preserve_withdrawal_insert": "CREATE TRIGGER facts_preserve_withdrawal_insert BEFORE INSERT ON public.facts FOR EACH ROW WHEN (((new.expired_at IS NULL) AND (COALESCE(current_setting('gbrain.fact_withdrawal_stamp_deferred'::text, true), ''::text) <> 'on'::text))) EXECUTE FUNCTION gbrain_preserve_fact_withdrawal()",- "facts.facts_refuse_purged": "CREATE TRIGGER facts_refuse_purged AFTER UPDATE OF fact, source_id, visibility, entity_slug ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_fact()",- "facts.facts_refuse_revived_withdrawal": "CREATE TRIGGER facts_refuse_revived_withdrawal AFTER UPDATE OF fact, source_id, visibility, entity_slug, expired_at ON public.facts FOR EACH ROW WHEN ((new.expired_at IS NULL)) EXECUTE FUNCTION gbrain_refuse_revived_withdrawn_fact()",- "facts.facts_refuse_unguarded_inserted": "CREATE TRIGGER facts_refuse_unguarded_inserted AFTER INSERT ON public.facts REFERENCING NEW TABLE AS inserted_facts FOR EACH STATEMENT EXECUTE FUNCTION gbrain_refuse_unguarded_inserted_facts()",+ "facts.facts_refuse_purged": "CREATE TRIGGER facts_refuse_purged BEFORE UPDATE OF fact, source_id, visibility, entity_slug ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_fact()","facts.gbrain_write_attribution": "CREATE TRIGGER gbrain_write_attribution BEFORE INSERT OR UPDATE ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_write_attribution()","facts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","facts.trust_generation_update": "CREATE CONSTRAINT TRIGGER trust_generation_update AFTER UPDATE ON public.facts DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ((old.trust_tier IS DISTINCT FROM new.trust_tier)) EXECUTE FUNCTION gbrain_bump_trust_generation()",@@ -4323,7 +4318,6 @@"page_body_manifest.page_body_manifest_derivation_scope_retire": "CREATE TRIGGER page_body_manifest_derivation_scope_retire AFTER UPDATE OF gen_to ON public.page_body_manifest FOR EACH ROW WHEN (((old.gen_to IS NULL) AND (new.gen_to IS NOT NULL) AND (old.staging_id IS NULL))) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry()","page_purges.trust_generation_insert": "CREATE CONSTRAINT TRIGGER trust_generation_insert AFTER INSERT ON public.page_purges DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN (true) EXECUTE FUNCTION gbrain_bump_trust_generation()","page_segment_derivations.page_segment_derivations_refuse_purging": "CREATE TRIGGER page_segment_derivations_refuse_purging BEFORE INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purging_derivation()",- "page_segment_derivations.page_segment_derivations_refuse_stored_purging": "CREATE TRIGGER page_segment_derivations_refuse_stored_purging AFTER INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_stored_purging_derivation()","page_segment_texts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.page_segment_texts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","page_versions.page_versions_trust_snapshot": "CREATE TRIGGER page_versions_trust_snapshot BEFORE INSERT ON public.page_versions FOR EACH ROW EXECUTE FUNCTION gbrain_snapshot_version_trust()","page_versions.page_versions_write_attribution": "CREATE TRIGGER page_versions_write_attribution BEFORE INSERT ON public.page_versions FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_version_attribution()",@@ -4335,7 +4329,7 @@"pages.pages_forget_retrievals": "CREATE TRIGGER pages_forget_retrievals AFTER DELETE ON public.pages REFERENCING OLD TABLE AS gbrain_deleted_pages FOR EACH STATEMENT EXECUTE FUNCTION gbrain_forget_page_retrievals()","pages.pages_knowledge_revision": "CREATE TRIGGER pages_knowledge_revision BEFORE UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_advance_page_revision()","pages.pages_projection_queue": "CREATE TRIGGER pages_projection_queue AFTER INSERT OR DELETE OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_queue_page_projection()",- "pages.pages_refuse_purged": "CREATE TRIGGER pages_refuse_purged AFTER INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_page()",+ "pages.pages_refuse_purged": "CREATE TRIGGER pages_refuse_purged BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_page()","pages.pages_revision_attribution": "CREATE TRIGGER pages_revision_attribution BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_revision_attribution()","pages.trg_pages_search_vector": "CREATE TRIGGER trg_pages_search_vector BEFORE INSERT OR UPDATE OF title, timeline, timeline_lead ON public.pages FOR EACH ROW EXECUTE FUNCTION update_page_search_vector()","pages.trust_generation_delete": "CREATE CONSTRAINT TRIGGER trust_generation_delete AFTER DELETE ON public.pages DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ((COALESCE(old.frontmatter, '{}'::jsonb) ? 'quarantine'::text)) EXECUTE FUNCTION gbrain_bump_trust_generation()",@@ -4359,7 +4353,7 @@"take_purges.trust_generation_insert": "CREATE CONSTRAINT TRIGGER trust_generation_insert AFTER INSERT ON public.take_purges DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN (true) EXECUTE FUNCTION gbrain_bump_trust_generation()","takes.gbrain_write_attribution": "CREATE TRIGGER gbrain_write_attribution BEFORE INSERT OR UPDATE ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_write_attribution()","takes.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()",- "takes.takes_refuse_purged": "CREATE TRIGGER takes_refuse_purged AFTER INSERT OR UPDATE OF claim, page_id ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_take()",+ "takes.takes_refuse_purged": "CREATE TRIGGER takes_refuse_purged BEFORE INSERT OR UPDATE OF claim, page_id ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_take()","takes.trust_generation_update": "CREATE CONSTRAINT TRIGGER trust_generation_update AFTER UPDATE ON public.takes DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ((old.trust_tier IS DISTINCT FROM new.trust_tier)) EXECUTE FUNCTION gbrain_bump_trust_generation()","takes.trust_tier_stamp": "CREATE TRIGGER trust_tier_stamp BEFORE INSERT OR UPDATE ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_trust_tier()","timeline_entries.gbrain_write_attribution": "CREATE TRIGGER gbrain_write_attribution BEFORE INSERT OR UPDATE ON public.timeline_entries FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_write_attribution()",diff --git a/test/fixtures/goldens/catalog/postgres-engine-init-fts-portuguese.json b/test/fixtures/goldens/catalog/postgres-engine-init-fts-portuguese.jsonindex acdb8620d5..c45f48d56f 100644--- a/test/fixtures/goldens/catalog/postgres-engine-init-fts-portuguese.json+++ b/test/fixtures/goldens/catalog/postgres-engine-init-fts-portuguese.json@@ -560,16 +560,13 @@"gbrain_guard_request_protocol()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=12baf1d365a8aa3009ac0fe6605497e6433304e8d5915a3fc0b0b39ad748f6c2","gbrain_guard_skill_publication()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=e854c0d058e75a65c3a90127c5c417380975100e83fc34288f6085e786df10a9","gbrain_lease_shared_skill_delivery()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=5e493c1ac8dce8cb025a736629e563437c4b214744137c302c532c20bf7e7acf",- "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4f2d679df92779f6941e2378b82d5a9d5fb5cb4fe8d571f4d69801e6f646bde6",+ "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=72ac0027fd37ecc4c72ad2e294ae3a98564736339b9ac917ea5d4112ec3cd35f","gbrain_preserve_fact_withdrawal()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=9beb118551a08451a228146373f50f2aa2ce0cfe89937e937d361b33224aa0aa","gbrain_queue_page_projection()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=6c544b9c129b6a17dcabeb5ee8d44a2b0e0af9d02ca3fe47c7d7f22ec313042c",- "gbrain_refuse_purged_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=08d7e84882d373c36a1db161eb9eed1da80ceb5d4373f65abc86f4e87e11a54f",- "gbrain_refuse_purged_page()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=9b08c031113955862b3bcd9f969c8ba721f7fe5c42aaa9992935fc4e7dd6e5ed",- "gbrain_refuse_purged_take()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=875112f8a4a7c22e349f0230c6bf5fd73331c3c54e542c3eaa896d3c21c868a3",- "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=05de18ee0111c91b4db21f46b6e99b20769ca0d69ec405ad6b48506dc23bbad6",- "gbrain_refuse_revived_withdrawn_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=7a383cc3e5c2742020f138aa962696f0e07d76f981295de0c38294a0c33f94ec",- "gbrain_refuse_stored_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4a3444d23904f780bb53285e3abc3ce1b079b27bf3faee2ef60b2915ad672146",- "gbrain_refuse_unguarded_inserted_facts()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=84360ce2ecf76f1dc9aaa00f5e7518531387e4a4bd53285f9ea617b27172bae5",+ "gbrain_refuse_purged_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=d1d584b91ceea7f4e63c235b790ef89c958c578e635f77ddd644918bc36d33f1",+ "gbrain_refuse_purged_page()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=8aaaf7c22fc9acb4b1e84fe75f11ae6c889949b78de1ef6bdba1db54ef43844e",+ "gbrain_refuse_purged_take()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=4a291b0448ab7a31926aa482b5222e0595d31a6bfad81b851b13e4bf581a0d83",+ "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=0d0afb3e61857f1668f2e7996da1c6aaf269aecaa1bf3763ce90df90e2d66fd3","gbrain_require_managed_writer()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=ae9883e69ac3121bc07689f68518c1d97a02a2788a64e496a26f12720300fe8a","gbrain_require_persistence_protocol(required integer)": "RETURNS void kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=af07b7fac60dec0a4fe568217931ac449d32f73b3a53a047b3b02a5f59cb5058","gbrain_snapshot_version_trust()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=7452350236ed4c68a6cd1f4d78a1381a4ef44cc70e8a032141f01bba4a704702",@@ -4306,9 +4303,7 @@"facts.facts_guard_inserted": "CREATE TRIGGER facts_guard_inserted AFTER INSERT ON public.facts REFERENCING NEW TABLE AS inserted_facts FOR EACH STATEMENT EXECUTE FUNCTION gbrain_guard_inserted_facts()","facts.facts_preserve_withdrawal": "CREATE TRIGGER facts_preserve_withdrawal BEFORE UPDATE OF fact, source_id, visibility, entity_slug, expired_at ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_preserve_fact_withdrawal()","facts.facts_preserve_withdrawal_insert": "CREATE TRIGGER facts_preserve_withdrawal_insert BEFORE INSERT ON public.facts FOR EACH ROW WHEN (((new.expired_at IS NULL) AND (COALESCE(current_setting('gbrain.fact_withdrawal_stamp_deferred'::text, true), ''::text) <> 'on'::text))) EXECUTE FUNCTION gbrain_preserve_fact_withdrawal()",- "facts.facts_refuse_purged": "CREATE TRIGGER facts_refuse_purged AFTER UPDATE OF fact, source_id, visibility, entity_slug ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_fact()",- "facts.facts_refuse_revived_withdrawal": "CREATE TRIGGER facts_refuse_revived_withdrawal AFTER UPDATE OF fact, source_id, visibility, entity_slug, expired_at ON public.facts FOR EACH ROW WHEN ((new.expired_at IS NULL)) EXECUTE FUNCTION gbrain_refuse_revived_withdrawn_fact()",- "facts.facts_refuse_unguarded_inserted": "CREATE TRIGGER facts_refuse_unguarded_inserted AFTER INSERT ON public.facts REFERENCING NEW TABLE AS inserted_facts FOR EACH STATEMENT EXECUTE FUNCTION gbrain_refuse_unguarded_inserted_facts()",+ "facts.facts_refuse_purged": "CREATE TRIGGER facts_refuse_purged BEFORE UPDATE OF fact, source_id, visibility, entity_slug ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_fact()","facts.gbrain_write_attribution": "CREATE TRIGGER gbrain_write_attribution BEFORE INSERT OR UPDATE ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_write_attribution()","facts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","facts.trust_generation_update": "CREATE CONSTRAINT TRIGGER trust_generation_update AFTER UPDATE ON public.facts DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ((old.trust_tier IS DISTINCT FROM new.trust_tier)) EXECUTE FUNCTION gbrain_bump_trust_generation()",@@ -4323,7 +4318,6 @@"page_body_manifest.page_body_manifest_derivation_scope_retire": "CREATE TRIGGER page_body_manifest_derivation_scope_retire AFTER UPDATE OF gen_to ON public.page_body_manifest FOR EACH ROW WHEN (((old.gen_to IS NULL) AND (new.gen_to IS NOT NULL) AND (old.staging_id IS NULL))) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry()","page_purges.trust_generation_insert": "CREATE CONSTRAINT TRIGGER trust_generation_insert AFTER INSERT ON public.page_purges DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN (true) EXECUTE FUNCTION gbrain_bump_trust_generation()","page_segment_derivations.page_segment_derivations_refuse_purging": "CREATE TRIGGER page_segment_derivations_refuse_purging BEFORE INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purging_derivation()",- "page_segment_derivations.page_segment_derivations_refuse_stored_purging": "CREATE TRIGGER page_segment_derivations_refuse_stored_purging AFTER INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_stored_purging_derivation()","page_segment_texts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.page_segment_texts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","page_versions.page_versions_trust_snapshot": "CREATE TRIGGER page_versions_trust_snapshot BEFORE INSERT ON public.page_versions FOR EACH ROW EXECUTE FUNCTION gbrain_snapshot_version_trust()","page_versions.page_versions_write_attribution": "CREATE TRIGGER page_versions_write_attribution BEFORE INSERT ON public.page_versions FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_version_attribution()",@@ -4335,7 +4329,7 @@"pages.pages_forget_retrievals": "CREATE TRIGGER pages_forget_retrievals AFTER DELETE ON public.pages REFERENCING OLD TABLE AS gbrain_deleted_pages FOR EACH STATEMENT EXECUTE FUNCTION gbrain_forget_page_retrievals()","pages.pages_knowledge_revision": "CREATE TRIGGER pages_knowledge_revision BEFORE UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_advance_page_revision()","pages.pages_projection_queue": "CREATE TRIGGER pages_projection_queue AFTER INSERT OR DELETE OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_queue_page_projection()",- "pages.pages_refuse_purged": "CREATE TRIGGER pages_refuse_purged AFTER INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_page()",+ "pages.pages_refuse_purged": "CREATE TRIGGER pages_refuse_purged BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_page()","pages.pages_revision_attribution": "CREATE TRIGGER pages_revision_attribution BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_revision_attribution()","pages.trg_pages_search_vector": "CREATE TRIGGER trg_pages_search_vector BEFORE INSERT OR UPDATE OF title, timeline, timeline_lead ON public.pages FOR EACH ROW EXECUTE FUNCTION update_page_search_vector()","pages.trust_generation_delete": "CREATE CONSTRAINT TRIGGER trust_generation_delete AFTER DELETE ON public.pages DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ((COALESCE(old.frontmatter, '{}'::jsonb) ? 'quarantine'::text)) EXECUTE FUNCTION gbrain_bump_trust_generation()",@@ -4359,7 +4353,7 @@"take_purges.trust_generation_insert": "CREATE CONSTRAINT TRIGGER trust_generation_insert AFTER INSERT ON public.take_purges DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN (true) EXECUTE FUNCTION gbrain_bump_trust_generation()","takes.gbrain_write_attribution": "CREATE TRIGGER gbrain_write_attribution BEFORE INSERT OR UPDATE ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_write_attribution()","takes.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()",- "takes.takes_refuse_purged": "CREATE TRIGGER takes_refuse_purged AFTER INSERT OR UPDATE OF claim, page_id ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_take()",+ "takes.takes_refuse_purged": "CREATE TRIGGER takes_refuse_purged BEFORE INSERT OR UPDATE OF claim, page_id ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_take()","takes.trust_generation_update": "CREATE CONSTRAINT TRIGGER trust_generation_update AFTER UPDATE ON public.takes DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ((old.trust_tier IS DISTINCT FROM new.trust_tier)) EXECUTE FUNCTION gbrain_bump_trust_generation()","takes.trust_tier_stamp": "CREATE TRIGGER trust_tier_stamp BEFORE INSERT OR UPDATE ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_trust_tier()","timeline_entries.gbrain_write_attribution": "CREATE TRIGGER gbrain_write_attribution BEFORE INSERT OR UPDATE ON public.timeline_entries FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_write_attribution()",diff --git a/test/fixtures/goldens/catalog/postgres-engine-init-high-dims.json b/test/fixtures/goldens/catalog/postgres-engine-init-high-dims.jsonindex e0bea0aea2..c6a0e8cfbf 100644--- a/test/fixtures/goldens/catalog/postgres-engine-init-high-dims.json+++ b/test/fixtures/goldens/catalog/postgres-engine-init-high-dims.json@@ -560,16 +560,13 @@"gbrain_guard_request_protocol()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=12baf1d365a8aa3009ac0fe6605497e6433304e8d5915a3fc0b0b39ad748f6c2","gbrain_guard_skill_publication()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=e854c0d058e75a65c3a90127c5c417380975100e83fc34288f6085e786df10a9","gbrain_lease_shared_skill_delivery()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=5e493c1ac8dce8cb025a736629e563437c4b214744137c302c532c20bf7e7acf",- "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4f2d679df92779f6941e2378b82d5a9d5fb5cb4fe8d571f4d69801e6f646bde6",+ "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=72ac0027fd37ecc4c72ad2e294ae3a98564736339b9ac917ea5d4112ec3cd35f","gbrain_preserve_fact_withdrawal()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=9beb118551a08451a228146373f50f2aa2ce0cfe89937e937d361b33224aa0aa","gbrain_queue_page_projection()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=6c544b9c129b6a17dcabeb5ee8d44a2b0e0af9d02ca3fe47c7d7f22ec313042c",- "gbrain_refuse_purged_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=08d7e84882d373c36a1db161eb9eed1da80ceb5d4373f65abc86f4e87e11a54f",- "gbrain_refuse_purged_page()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=9b08c031113955862b3bcd9f969c8ba721f7fe5c42aaa9992935fc4e7dd6e5ed",- "gbrain_refuse_purged_take()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=875112f8a4a7c22e349f0230c6bf5fd73331c3c54e542c3eaa896d3c21c868a3",- "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=05de18ee0111c91b4db21f46b6e99b20769ca0d69ec405ad6b48506dc23bbad6",- "gbrain_refuse_revived_withdrawn_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=7a383cc3e5c2742020f138aa962696f0e07d76f981295de0c38294a0c33f94ec",- "gbrain_refuse_stored_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4a3444d23904f780bb53285e3abc3ce1b079b27bf3faee2ef60b2915ad672146",- "gbrain_refuse_unguarded_inserted_facts()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=84360ce2ecf76f1dc9aaa00f5e7518531387e4a4bd53285f9ea617b27172bae5",+ "gbrain_refuse_purged_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=d1d584b91ceea7f4e63c235b790ef89c958c578e635f77ddd644918bc36d33f1",+ "gbrain_refuse_purged_page()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=8aaaf7c22fc9acb4b1e84fe75f11ae6c889949b78de1ef6bdba1db54ef43844e",+ "gbrain_refuse_purged_take()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=4a291b0448ab7a31926aa482b5222e0595d31a6bfad81b851b13e4bf581a0d83",+ "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=0d0afb3e61857f1668f2e7996da1c6aaf269aecaa1bf3763ce90df90e2d66fd3","gbrain_require_managed_writer()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=ae9883e69ac3121bc07689f68518c1d97a02a2788a64e496a26f12720300fe8a","gbrain_require_persistence_protocol(required integer)": "RETURNS void kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=af07b7fac60dec0a4fe568217931ac449d32f73b3a53a047b3b02a5f59cb5058","gbrain_snapshot_version_trust()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=7452350236ed4c68a6cd1f4d78a1381a4ef44cc70e8a032141f01bba4a704702",@@ -4302,9 +4299,7 @@"facts.facts_guard_inserted": "CREATE TRIGGER facts_guard_inserted AFTER INSERT ON public.facts REFERENCING NEW TABLE AS inserted_facts FOR EACH STATEMENT EXECUTE FUNCTION gbrain_guard_inserted_facts()","facts.facts_preserve_withdrawal": "CREATE TRIGGER facts_preserve_withdrawal BEFORE UPDATE OF fact, source_id, visibility, entity_slug, expired_at ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_preserve_fact_withdrawal()","facts.facts_preserve_withdrawal_insert": "CREATE TRIGGER facts_preserve_withdrawal_insert BEFORE INSERT ON public.facts FOR EACH ROW WHEN (((new.expired_at IS NULL) AND (COALESCE(current_setting('gbrain.fact_withdrawal_stamp_deferred'::text, true), ''::text) <> 'on'::text))) EXECUTE FUNCTION gbrain_preserve_fact_withdrawal()",- "facts.facts_refuse_purged": "CREATE TRIGGER facts_refuse_purged AFTER UPDATE OF fact, source_id, visibility, entity_slug ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_fact()",- "facts.facts_refuse_revived_withdrawal": "CREATE TRIGGER facts_refuse_revived_withdrawal AFTER UPDATE OF fact, source_id, visibility, entity_slug, expired_at ON public.facts FOR EACH ROW WHEN ((new.expired_at IS NULL)) EXECUTE FUNCTION gbrain_refuse_revived_withdrawn_fact()",- "facts.facts_refuse_unguarded_inserted": "CREATE TRIGGER facts_refuse_unguarded_inserted AFTER INSERT ON public.facts REFERENCING NEW TABLE AS inserted_facts FOR EACH STATEMENT EXECUTE FUNCTION gbrain_refuse_unguarded_inserted_facts()",+ "facts.facts_refuse_purged": "CREATE TRIGGER facts_refuse_purged BEFORE UPDATE OF fact, source_id, visibility, entity_slug ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_fact()","facts.gbrain_write_attribution": "CREATE TRIGGER gbrain_write_attribution BEFORE INSERT OR UPDATE ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_write_attribution()","facts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","facts.trust_generation_update": "CREATE CONSTRAINT TRIGGER trust_generation_update AFTER UPDATE ON public.facts DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ((old.trust_tier IS DISTINCT FROM new.trust_tier)) EXECUTE FUNCTION gbrain_bump_trust_generation()",@@ -4319,7 +4314,6 @@"page_body_manifest.page_body_manifest_derivation_scope_retire": "CREATE TRIGGER page_body_manifest_derivation_scope_retire AFTER UPDATE OF gen_to ON public.page_body_manifest FOR EACH ROW WHEN (((old.gen_to IS NULL) AND (new.gen_to IS NOT NULL) AND (old.staging_id IS NULL))) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry()","page_purges.trust_generation_insert": "CREATE CONSTRAINT TRIGGER trust_generation_insert AFTER INSERT ON public.page_purges DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN (true) EXECUTE FUNCTION gbrain_bump_trust_generation()","page_segment_derivations.page_segment_derivations_refuse_purging": "CREATE TRIGGER page_segment_derivations_refuse_purging BEFORE INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purging_derivation()",- "page_segment_derivations.page_segment_derivations_refuse_stored_purging": "CREATE TRIGGER page_segment_derivations_refuse_stored_purging AFTER INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_stored_purging_derivation()","page_segment_texts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.page_segment_texts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","page_versions.page_versions_trust_snapshot": "CREATE TRIGGER page_versions_trust_snapshot BEFORE INSERT ON public.page_versions FOR EACH ROW EXECUTE FUNCTION gbrain_snapshot_version_trust()","page_versions.page_versions_write_attribution": "CREATE TRIGGER page_versions_write_attribution BEFORE INSERT ON public.page_versions FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_version_attribution()",@@ -4331,7 +4325,7 @@"pages.pages_forget_retrievals": "CREATE TRIGGER pages_forget_retrievals AFTER DELETE ON public.pages REFERENCING OLD TABLE AS gbrain_deleted_pages FOR EACH STATEMENT EXECUTE FUNCTION gbrain_forget_page_retrievals()","pages.pages_knowledge_revision": "CREATE TRIGGER pages_knowledge_revision BEFORE UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_advance_page_revision()","pages.pages_projection_queue": "CREATE TRIGGER pages_projection_queue AFTER INSERT OR DELETE OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_queue_page_projection()",- "pages.pages_refuse_purged": "CREATE TRIGGER pages_refuse_purged AFTER INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_page()",+ "pages.pages_refuse_purged": "CREATE TRIGGER pages_refuse_purged BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_page()","pages.pages_revision_attribution": "CREATE TRIGGER pages_revision_attribution BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_revision_attribution()","pages.trg_pages_search_vector": "CREATE TRIGGER trg_pages_search_vector BEFORE INSERT OR UPDATE OF title, timeline, timeline_lead ON public.pages FOR EACH ROW EXECUTE FUNCTION update_page_search_vector()","pages.trust_generation_delete": "CREATE CONSTRAINT TRIGGER trust_generation_delete AFTER DELETE ON public.pages DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ((COALESCE(old.frontmatter, '{}'::jsonb) ? 'quarantine'::text)) EXECUTE FUNCTION gbrain_bump_trust_generation()",@@ -4355,7 +4349,7 @@"take_purges.trust_generation_insert": "CREATE CONSTRAINT TRIGGER trust_generation_insert AFTER INSERT ON public.take_purges DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN (true) EXECUTE FUNCTION gbrain_bump_trust_generation()","takes.gbrain_write_attribution": "CREATE TRIGGER gbrain_write_attribution BEFORE INSERT OR UPDATE ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_write_attribution()","takes.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()",- "takes.takes_refuse_purged": "CREATE TRIGGER takes_refuse_purged AFTER INSERT OR UPDATE OF claim, page_id ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_take()",+ "takes.takes_refuse_purged": "CREATE TRIGGER takes_refuse_purged BEFORE INSERT OR UPDATE OF claim, page_id ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_take()","takes.trust_generation_update": "CREATE CONSTRAINT TRIGGER trust_generation_update AFTER UPDATE ON public.takes DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ((old.trust_tier IS DISTINCT FROM new.trust_tier)) EXECUTE FUNCTION gbrain_bump_trust_generation()","takes.trust_tier_stamp": "CREATE TRIGGER trust_tier_stamp BEFORE INSERT OR UPDATE ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_trust_tier()","timeline_entries.gbrain_write_attribution": "CREATE TRIGGER gbrain_write_attribution BEFORE INSERT OR UPDATE ON public.timeline_entries FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_write_attribution()",diff --git a/test/fixtures/goldens/doctor/hot-checks-pglite-json.json b/test/fixtures/goldens/doctor/hot-checks-pglite-json.jsonindex 7b91bc13ac..3b0b3416b1 100644--- a/test/fixtures/goldens/doctor/hot-checks-pglite-json.json+++ b/test/fixtures/goldens/doctor/hot-checks-pglite-json.json@@ -1123,8 +1123,8 @@{"category": "ops","elapsed_ms": "<volatile>",- "message": "Skipped (PGLite: one role, so every guard reads every row)",- "name": "guard_functions",+ "message": "Every gbrain function that pins a search_path ends it with pg_temp",+ "name": "function_search_path","status": "ok"},{@@ -5865,8 +5865,8 @@{"category": "ops","elapsed_ms": "<volatile>",- "message": "Skipped (PGLite: one role, so every guard reads every row)",- "name": "guard_functions",+ "message": "Every gbrain function that pins a search_path ends it with pg_temp",+ "name": "function_search_path","status": "ok"},{diff --git a/test/fixtures/goldens/doctor/hot-checks-postgres-json.json b/test/fixtures/goldens/doctor/hot-checks-postgres-json.jsonindex 8788ac95f4..5bae2af78d 100644--- a/test/fixtures/goldens/doctor/hot-checks-postgres-json.json+++ b/test/fixtures/goldens/doctor/hot-checks-postgres-json.json@@ -1119,8 +1119,8 @@{"category": "ops","elapsed_ms": "<volatile>",- "message": "The 7 purge and withdrawal guards read their ledgers as their owner; every gbrain function pins pg_temp last",- "name": "guard_functions",+ "message": "Every gbrain function that pins a search_path ends it with pg_temp",+ "name": "function_search_path","status": "ok"},{@@ -5862,8 +5862,8 @@{"category": "ops","elapsed_ms": "<volatile>",- "message": "The 7 purge and withdrawal guards read their ledgers as their owner; every gbrain function pins pg_temp last",- "name": "guard_functions",+ "message": "Every gbrain function that pins a search_path ends it with pg_temp",+ "name": "function_search_path","status": "ok"},{diff --git a/test/fixtures/goldens/doctor/json-pglite-degraded.json b/test/fixtures/goldens/doctor/json-pglite-degraded.jsonindex ccb223af18..78f3069e1f 100644--- a/test/fixtures/goldens/doctor/json-pglite-degraded.json+++ b/test/fixtures/goldens/doctor/json-pglite-degraded.json@@ -965,8 +965,8 @@{"category": "ops","elapsed_ms": "<volatile>",- "message": "Skipped (PGLite: one role, so every guard reads every row)",- "name": "guard_functions",+ "message": "Every gbrain function that pins a search_path ends it with pg_temp",+ "name": "function_search_path","status": "ok"},{diff --git a/test/fixtures/goldens/doctor/json-pglite-fresh.json b/test/fixtures/goldens/doctor/json-pglite-fresh.jsonindex 4fb751d3b6..cd079540e6 100644--- a/test/fixtures/goldens/doctor/json-pglite-fresh.json+++ b/test/fixtures/goldens/doctor/json-pglite-fresh.json@@ -1012,8 +1012,8 @@{"category": "ops","elapsed_ms": "<volatile>",- "message": "Skipped (PGLite: one role, so every guard reads every row)",- "name": "guard_functions",+ "message": "Every gbrain function that pins a search_path ends it with pg_temp",+ "name": "function_search_path","status": "ok"},{diff --git a/test/fixtures/goldens/doctor/json-postgres-fresh.json b/test/fixtures/goldens/doctor/json-postgres-fresh.jsonindex 1419e88562..8a91b0cd26 100644--- a/test/fixtures/goldens/doctor/json-postgres-fresh.json+++ b/test/fixtures/goldens/doctor/json-postgres-fresh.json@@ -1008,8 +1008,8 @@{"category": "ops","elapsed_ms": "<volatile>",- "message": "The 7 purge and withdrawal guards read their ledgers as their owner; every gbrain function pins pg_temp last",- "name": "guard_functions",+ "message": "Every gbrain function that pins a search_path ends it with pg_temp",+ "name": "function_search_path","status": "ok"},{diff --git a/test/fixtures/goldens/doctor/registry-build-checks.json b/test/fixtures/goldens/doctor/registry-build-checks.jsonindex 4dc22665a9..62f403be06 100644--- a/test/fixtures/goldens/doctor/registry-build-checks.json+++ b/test/fixtures/goldens/doctor/registry-build-checks.json@@ -359,7 +359,7 @@},{"category": "ops",- "name": "guard_functions"+ "name": "function_search_path"},{"category": "meta",diff --git a/test/fixtures/goldens/migrations/records.json b/test/fixtures/goldens/migrations/records.jsonindex fb7b53459d..942ec3254c 100644--- a/test/fixtures/goldens/migrations/records.json+++ b/test/fixtures/goldens/migrations/records.json@@ -15,12 +15,6 @@"CONTENT_CHUNKS_GENERATION_INDEX": "c434b3a4acdad499cf3b9f170d9f9967b8e3e8218c829db99f3ecba3b53c8b5d","CONTENT_CHUNKS_OCCURRENCE_GENERATION_INDEX": "b4f73db97ad878ef7256128ddef83fd11e2e08fd215e389d9e921a0daf04853d","CONTENT_CHUNKS_OCCURRENCE_INDEX": "7b692ba777b30399ab5a3b100eb40b3b9d1b3fb2322dc4dc808ba8a4d667912c",- "DEFINER_FUNCTION_SQL": "ca03804c9a449a42b1d95474e29a43b31f0804b8c7b329bf4a163c7b7f71a39c",- "DEFINER_GUARDS": "03b33d9e251774efabb14c9f324264959587b8657e75ee65fd30432241918ce3",- "DEFINER_TRIGGERS": "d0408baa4ec464b104ed133b5916a39dfd22880bc5fcd0a324e3cd739c5fc668",- "DERIVATION_SCOPE_ENTRY_FUNCTION_SQL": "1477f86e1c50cd947716b84f6339f1d2899eeee86330957fc9b2fa581bd2d21e",- "DERIVATION_STORED_GUARD_FUNCTION_SQL": "62257732f75bf48f37268217a81e371441db5410779a392d665801c36040809a",- "DERIVATION_STORED_GUARD_TRIGGER_SQL": "ff55e347bb9cf69dbd540500909cf59a497ad0e6d3fcc40bb9c0e0e3fe8b3860","EXEMPT_RE": "e8b623114f4f77fc3abcfc479abec1442dbf41bc607e046d124b44572d59953c","FACTS_SUPERSEDED_BY_INDEX": "555c2b267989359a078de0f82cea830584bc0a268be6796bf526c0a9bed45905","FACT_PURGES_ALL_SUBJECTS_INDEX": "99e2eb6c24134b539cb4cfd6e5ff66a724463525d09e9ba1fdde3c13f5787b6c",@@ -30,8 +24,6 @@"FTS_CJK_BOUNDARY_REGEX": "e8605bc0f2c6f3ecd2b451cbc8a4fe27ae0974d048f0bea655533cf37e0ff88d","FTS_INPUT_FUNCTION_SQL": "d2f44fc1ef338ff7563c07659d938b743fedb20230948792c71068c022ec54c3","FUNCTION_SEARCH_PATH_HARDENING_SQL": "25ac6f1fedd5cf69582c79eceeaae58e5a7cf779e5cedbbfc4985b3702e37526",- "GUARD_FUNCTION_SQL": "f25f1638357f309c3c50524dc86f3564aa836d28efc86a3dd4d72eec1302ecc6",- "GUARD_TRIGGERS": "ec81fc215a2ab1864b95045a48266cdd8148cade94c169b52b0f464c587111fe","INGEST_LOG_MARKED_INDEX": "1099f19af7873878974239a9a6f1a627827221eebd75aea01896246e0809e91c","INGEST_LOG_UNMARKED_INDEX": "c94e6b009f830527d2f1d6af1683bee94189474e8e67aa4c60165ab4abbd8726","ISSUANCE_CLOCK_SLACK_SECONDS": "8f36c80392df6f9b9c754826289b63969d9d41ca8955213291e4413d614dce35",@@ -71,9 +63,8 @@"ensureFactsFtsIndex": "95e723314ac30cea2db48e0e167c554ef1fa06df80cae765faa2a080a3a655c2","getFtsLanguage": "0d790b4c4af1f67a2a1bbd59470beb13f434917b381931baf8404a41c5d903db","grantFromRow": "2d0603bb0f964d7e45e04aa76bac54cd4f6f63c91a8d9f028b60b4792bc1695e",- "hardenGuards": "80ee96125eb9075a4145e62ef2bea49f9b95c6e9a47a081918c4acc28ad9d9ba",+ "hardenFunctionSearchPaths": "a82d480ce4f68e8e3e9540a186f285a03975d4084a7d076d191e1551214b693f","hnswMaxDimsForType": "a187cdcc520f813b7c39da97ce53da58509232ed9f851627ef41abfe1b68bd26",- "inShortTransaction": "366c67944d8aeb6b71450da05259a0fa5005fa8f6ec6091671f3c78a682db216","isLockTimeoutError": "52a3720e1ffb74ce381cc3269f78130c38a89c807e308283ec3d557bae2b89b1","lockTableForAnalyze": "b6e4f173cffd877d2cfd85af813aa694a6d2c32907eaea613c6879800d3a7b44","migrateAutoThinkToPins": "34267fe3b1cc4ab2850ddcf9ba18ce73d959678233a53de238c85231e6b71470",@@ -4410,8 +4401,8 @@"idempotent": true,"name": "segment_derivations","sql": {- "length": 9439,- "sha256": "1213f5e694ad49ea2847bcfef9e540cc6874d880b9d3507aff94a8667d9d354a"+ "length": 6527,+ "sha256": "6817b97b501c8fadfb66177fa317ecd4e1a05ef879cc0c411df134f99019e491"},"sqlFor": "absent","transaction": false,@@ -4462,27 +4453,18 @@"handler": {"form": "arrow","helpers": [- "DEFINER_FUNCTION_SQL",- "DEFINER_GUARDS",- "DEFINER_TRIGGERS",- "DERIVATION_SCOPE_ENTRY_FUNCTION_SQL",- "DERIVATION_STORED_GUARD_FUNCTION_SQL",- "DERIVATION_STORED_GUARD_TRIGGER_SQL","FUNCTION_SEARCH_PATH_HARDENING_SQL",- "GUARD_FUNCTION_SQL",- "GUARD_TRIGGERS","LEGACY_SEARCH_PATH_SETTINGS",- "hardenGuards",- "inShortTransaction",+ "hardenFunctionSearchPaths","isLockTimeoutError","migrationStatementTimeoutMs","resolveSchemaLockTimeoutMs","schemaLockBlockedError"],- "sha256": "fa372affae3794ac88f4335ecf613e5a7b8d67fd08acb50d57d57fd961b53bde"+ "sha256": "60b6bf855bfd2b0e950999a6c183de96e826507e305b1939eefe5c6c8f343975"},"idempotent": true,- "name": "guard_triggers_security_definer",+ "name": "function_search_path_pg_temp","sql": {"length": 0,"sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"diff --git a/test/fixtures/goldens/pglite-upgrade-replay/catalog-after-boot.json b/test/fixtures/goldens/pglite-upgrade-replay/catalog-after-boot.jsonindex 52123d3c82..a3d0f5e2cb 100644--- a/test/fixtures/goldens/pglite-upgrade-replay/catalog-after-boot.json+++ b/test/fixtures/goldens/pglite-upgrade-replay/catalog-after-boot.json@@ -557,16 +557,13 @@"gbrain_guard_request_protocol()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=12baf1d365a8aa3009ac0fe6605497e6433304e8d5915a3fc0b0b39ad748f6c2","gbrain_guard_skill_publication()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=e854c0d058e75a65c3a90127c5c417380975100e83fc34288f6085e786df10a9","gbrain_lease_shared_skill_delivery()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=5e493c1ac8dce8cb025a736629e563437c4b214744137c302c532c20bf7e7acf",- "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4f2d679df92779f6941e2378b82d5a9d5fb5cb4fe8d571f4d69801e6f646bde6",+ "gbrain_mark_derivation_scope_entry()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=72ac0027fd37ecc4c72ad2e294ae3a98564736339b9ac917ea5d4112ec3cd35f","gbrain_preserve_fact_withdrawal()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=9beb118551a08451a228146373f50f2aa2ce0cfe89937e937d361b33224aa0aa","gbrain_queue_page_projection()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=6c544b9c129b6a17dcabeb5ee8d44a2b0e0af9d02ca3fe47c7d7f22ec313042c",- "gbrain_refuse_purged_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=08d7e84882d373c36a1db161eb9eed1da80ceb5d4373f65abc86f4e87e11a54f",- "gbrain_refuse_purged_page()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=9b08c031113955862b3bcd9f969c8ba721f7fe5c42aaa9992935fc4e7dd6e5ed",- "gbrain_refuse_purged_take()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=875112f8a4a7c22e349f0230c6bf5fd73331c3c54e542c3eaa896d3c21c868a3",- "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=05de18ee0111c91b4db21f46b6e99b20769ca0d69ec405ad6b48506dc23bbad6",- "gbrain_refuse_revived_withdrawn_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=7a383cc3e5c2742020f138aa962696f0e07d76f981295de0c38294a0c33f94ec",- "gbrain_refuse_stored_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=4a3444d23904f780bb53285e3abc3ce1b079b27bf3faee2ef60b2915ad672146",- "gbrain_refuse_unguarded_inserted_facts()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=true config=[search_path=pg_catalog, pg_temp] body_sha256=84360ce2ecf76f1dc9aaa00f5e7518531387e4a4bd53285f9ea617b27172bae5",+ "gbrain_refuse_purged_fact()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=d1d584b91ceea7f4e63c235b790ef89c958c578e635f77ddd644918bc36d33f1",+ "gbrain_refuse_purged_page()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=8aaaf7c22fc9acb4b1e84fe75f11ae6c889949b78de1ef6bdba1db54ef43844e",+ "gbrain_refuse_purged_take()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=4a291b0448ab7a31926aa482b5222e0595d31a6bfad81b851b13e4bf581a0d83",+ "gbrain_refuse_purging_derivation()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=0d0afb3e61857f1668f2e7996da1c6aaf269aecaa1bf3763ce90df90e2d66fd3","gbrain_require_managed_writer()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=ae9883e69ac3121bc07689f68518c1d97a02a2788a64e496a26f12720300fe8a","gbrain_require_persistence_protocol(required integer)": "RETURNS void kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=af07b7fac60dec0a4fe568217931ac449d32f73b3a53a047b3b02a5f59cb5058","gbrain_snapshot_version_trust()": "RETURNS trigger kind=f lang=plpgsql volatility=v secdef=false config=[search_path=pg_catalog, public, pg_temp] body_sha256=7452350236ed4c68a6cd1f4d78a1381a4ef44cc70e8a032141f01bba4a704702",@@ -4314,9 +4311,7 @@"facts.facts_guard_inserted": "CREATE TRIGGER facts_guard_inserted AFTER INSERT ON public.facts REFERENCING NEW TABLE AS inserted_facts FOR EACH STATEMENT EXECUTE FUNCTION gbrain_guard_inserted_facts()","facts.facts_preserve_withdrawal": "CREATE TRIGGER facts_preserve_withdrawal BEFORE UPDATE OF fact, source_id, visibility, entity_slug, expired_at ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_preserve_fact_withdrawal()","facts.facts_preserve_withdrawal_insert": "CREATE TRIGGER facts_preserve_withdrawal_insert BEFORE INSERT ON public.facts FOR EACH ROW WHEN (((new.expired_at IS NULL) AND (COALESCE(current_setting('gbrain.fact_withdrawal_stamp_deferred'::text, true), ''::text) <> 'on'::text))) EXECUTE FUNCTION gbrain_preserve_fact_withdrawal()",- "facts.facts_refuse_purged": "CREATE TRIGGER facts_refuse_purged AFTER UPDATE OF fact, source_id, visibility, entity_slug ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_fact()",- "facts.facts_refuse_revived_withdrawal": "CREATE TRIGGER facts_refuse_revived_withdrawal AFTER UPDATE OF fact, source_id, visibility, entity_slug, expired_at ON public.facts FOR EACH ROW WHEN ((new.expired_at IS NULL)) EXECUTE FUNCTION gbrain_refuse_revived_withdrawn_fact()",- "facts.facts_refuse_unguarded_inserted": "CREATE TRIGGER facts_refuse_unguarded_inserted AFTER INSERT ON public.facts REFERENCING NEW TABLE AS inserted_facts FOR EACH STATEMENT EXECUTE FUNCTION gbrain_refuse_unguarded_inserted_facts()",+ "facts.facts_refuse_purged": "CREATE TRIGGER facts_refuse_purged BEFORE UPDATE OF fact, source_id, visibility, entity_slug ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_fact()","facts.gbrain_write_attribution": "CREATE TRIGGER gbrain_write_attribution BEFORE INSERT OR UPDATE ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_write_attribution()","facts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.facts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","facts.planner_stats_del": "CREATE TRIGGER planner_stats_del AFTER DELETE ON public.facts REFERENCING OLD TABLE AS old_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()",@@ -4336,7 +4331,6 @@"page_body_manifest.page_body_manifest_derivation_scope_retire": "CREATE TRIGGER page_body_manifest_derivation_scope_retire AFTER UPDATE OF gen_to ON public.page_body_manifest FOR EACH ROW WHEN (((old.gen_to IS NULL) AND (new.gen_to IS NOT NULL) AND (old.staging_id IS NULL))) EXECUTE FUNCTION gbrain_mark_derivation_scope_entry()","page_purges.trust_generation_insert": "CREATE CONSTRAINT TRIGGER trust_generation_insert AFTER INSERT ON public.page_purges DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN (true) EXECUTE FUNCTION gbrain_bump_trust_generation()","page_segment_derivations.page_segment_derivations_refuse_purging": "CREATE TRIGGER page_segment_derivations_refuse_purging BEFORE INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purging_derivation()",- "page_segment_derivations.page_segment_derivations_refuse_stored_purging": "CREATE TRIGGER page_segment_derivations_refuse_stored_purging AFTER INSERT OR UPDATE OF output, receipt ON public.page_segment_derivations FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_stored_purging_derivation()","page_segment_texts.managed_writer_guard": "CREATE TRIGGER managed_writer_guard BEFORE INSERT OR DELETE OR UPDATE ON public.page_segment_texts FOR EACH ROW EXECUTE FUNCTION gbrain_require_managed_writer()","page_versions.page_versions_trust_snapshot": "CREATE TRIGGER page_versions_trust_snapshot BEFORE INSERT ON public.page_versions FOR EACH ROW EXECUTE FUNCTION gbrain_snapshot_version_trust()","page_versions.page_versions_write_attribution": "CREATE TRIGGER page_versions_write_attribution BEFORE INSERT ON public.page_versions FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_version_attribution()",@@ -4348,7 +4342,7 @@"pages.pages_forget_retrievals": "CREATE TRIGGER pages_forget_retrievals AFTER DELETE ON public.pages REFERENCING OLD TABLE AS gbrain_deleted_pages FOR EACH STATEMENT EXECUTE FUNCTION gbrain_forget_page_retrievals()","pages.pages_knowledge_revision": "CREATE TRIGGER pages_knowledge_revision BEFORE UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_advance_page_revision()","pages.pages_projection_queue": "CREATE TRIGGER pages_projection_queue AFTER INSERT OR DELETE OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_queue_page_projection()",- "pages.pages_refuse_purged": "CREATE TRIGGER pages_refuse_purged AFTER INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_page()",+ "pages.pages_refuse_purged": "CREATE TRIGGER pages_refuse_purged BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_page()","pages.pages_revision_attribution": "CREATE TRIGGER pages_revision_attribution BEFORE INSERT OR UPDATE ON public.pages FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_revision_attribution()","pages.planner_stats_del": "CREATE TRIGGER planner_stats_del AFTER DELETE ON public.pages REFERENCING OLD TABLE AS old_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()","pages.planner_stats_ins": "CREATE TRIGGER planner_stats_ins AFTER INSERT ON public.pages REFERENCING NEW TABLE AS new_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()",@@ -4378,7 +4372,7 @@"takes.planner_stats_del": "CREATE TRIGGER planner_stats_del AFTER DELETE ON public.takes REFERENCING OLD TABLE AS old_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()","takes.planner_stats_ins": "CREATE TRIGGER planner_stats_ins AFTER INSERT ON public.takes REFERENCING NEW TABLE AS new_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()","takes.planner_stats_upd": "CREATE TRIGGER planner_stats_upd AFTER UPDATE ON public.takes REFERENCING NEW TABLE AS new_rows FOR EACH STATEMENT EXECUTE FUNCTION gbrain_count_modifications()",- "takes.takes_refuse_purged": "CREATE TRIGGER takes_refuse_purged AFTER INSERT OR UPDATE OF claim, page_id ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_take()",+ "takes.takes_refuse_purged": "CREATE TRIGGER takes_refuse_purged BEFORE INSERT OR UPDATE OF claim, page_id ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_refuse_purged_take()","takes.trust_generation_update": "CREATE CONSTRAINT TRIGGER trust_generation_update AFTER UPDATE ON public.takes DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ((old.trust_tier IS DISTINCT FROM new.trust_tier)) EXECUTE FUNCTION gbrain_bump_trust_generation()","takes.trust_tier_stamp": "CREATE TRIGGER trust_tier_stamp BEFORE INSERT OR UPDATE ON public.takes FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_trust_tier()","timeline_entries.gbrain_write_attribution": "CREATE TRIGGER gbrain_write_attribution BEFORE INSERT OR UPDATE ON public.timeline_entries FOR EACH ROW EXECUTE FUNCTION gbrain_stamp_write_attribution()",diff --git a/test/fixtures/goldens/pglite-upgrade-replay/repeat-boot-recreated-objects.json b/test/fixtures/goldens/pglite-upgrade-replay/repeat-boot-recreated-objects.jsonindex bb845117ed..95298c8314 100644--- a/test/fixtures/goldens/pglite-upgrade-replay/repeat-boot-recreated-objects.json+++ b/test/fixtures/goldens/pglite-upgrade-replay/repeat-boot-recreated-objects.json@@ -7,7 +7,6 @@"trg:page_body_manifest.page_body_manifest_derivation_scope_delete","trg:page_body_manifest.page_body_manifest_derivation_scope_retire","trg:page_segment_derivations.page_segment_derivations_refuse_purging",- "trg:page_segment_derivations.page_segment_derivations_refuse_stored_purging","trg:page_segment_texts.managed_writer_guard","trg:pages.bump_page_generation_clock_trg","trg:pages.bump_page_generation_trg",diff --git a/test/function-search-path-pglite.test.ts b/test/function-search-path-pglite.test.tsnew file mode 100644index 0000000000..8f4e8cc5f4--- /dev/null+++ b/test/function-search-path-pglite.test.ts@@ -0,0 +1,54 @@+/**+ * #7632 on PGLite: every gbrain function that pins a search_path ends it with pg_temp, so a temp table named like a+ * purge or withdrawal ledger hides nothing from the guard that reads it. PGLite has one role, the owner, and before the+ * change its guards read the empty temp table and stored the purged write. The guards are otherwise as on master.+ */+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';+import { PGLiteEngine } from '../src/core/pglite-engine.ts';++const PURGED_CLAIM = 'alice-example joined acme-example as cto';+const WITHDRAWN_CLAIM = 'alice-example lives in city-a';+const PURGED_TAKE = 'acme-example will double revenue';+const PURGED_HASH = 'deadbeefcafe00000000000000000002';+const SHADOWED = ['fact_purges', 'fact_withdrawals', 'take_purges', 'page_purges'];++describe('function search_path ends in pg_temp on PGLite (#7632)', () => {+ let engine: PGLiteEngine;+ let takesPage = 0;+ beforeAll(async () => {+ engine = new PGLiteEngine();+ await engine.connect({});+ await engine.initSchema();+ const [page] = await engine.executeRaw<{ id: number }>(`INSERT INTO pages (slug, type, title, compiled_truth) VALUES ('people/alice-example', 'person', 'a', 'x') RETURNING id`);+ takesPage = page!.id;+ await engine.executeRaw(`INSERT INTO fact_purges (source_id, visibility, subject, fact_hash) VALUES ('default', 'private', '*', gbrain_fact_fingerprint($1))`, [PURGED_CLAIM]);+ await engine.executeRaw(`INSERT INTO fact_withdrawals (source_id, visibility, subject, fact_hash) VALUES ('default', 'private', '*', gbrain_fact_fingerprint($1))`, [WITHDRAWN_CLAIM]);+ await engine.executeRaw(`INSERT INTO page_purges (source_id, content_hash, slug) VALUES ('default', $1, 'notes/purged-example')`, [PURGED_HASH]);+ await engine.executeRaw(`INSERT INTO take_purges (source_id, subject, claim_hash) VALUES ('default', '*', gbrain_fact_fingerprint($1))`, [PURGED_TAKE]);+ }, 120_000);+ afterAll(async () => { await engine?.disconnect(); });++ test('every function that pins a search_path ends it with pg_temp, and none is SECURITY DEFINER', async () => {+ const rows = await engine.executeRaw<{ sig: string; setting: string; secdef: boolean }>(+ `SELECT p.oid::regprocedure::text AS sig, s.setting, p.prosecdef AS secdef FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace+ CROSS JOIN LATERAL unnest(p.proconfig) AS s(setting) WHERE n.nspname = 'public' AND s.setting LIKE 'search_path=%' ORDER BY 1`);+ expect(rows.length).toBeGreaterThanOrEqual(35);+ expect(rows.filter(r => !r.setting.endsWith(', pg_temp') || r.secdef).map(r => r.sig)).toEqual([]);+ });++ test('temp tables named like the ledgers hide nothing: purged writes are refused and a withdrawn fact is stamped', async () => {+ const attempt = (sql: string, params: unknown[]) => engine.executeRaw(sql, params).then(() => 'stored', (e: Error) => e.message.split(':')[0]);+ try {+ for (const ledger of SHADOWED) await engine.executeRaw(`CREATE TEMP TABLE ${ledger} (LIKE public.${ledger})`);+ const fact = await attempt(`INSERT INTO facts (fact, source) VALUES ($1, 'probe')`, [PURGED_CLAIM]);+ const page = await attempt(`INSERT INTO pages (slug, type, title, compiled_truth, content_hash) VALUES ('notes/again-example', 'note', 't', 'x', $1)`, [PURGED_HASH]);+ const take = await attempt(`INSERT INTO takes (page_id, row_num, claim, kind, holder) VALUES ($1, 1, $2, 'take', 'alice-example')`, [takesPage, PURGED_TAKE]);+ const [w] = await engine.executeRaw<{ id: number }>(`INSERT INTO facts (fact, source) VALUES ($1, 'probe') RETURNING id`, [WITHDRAWN_CLAIM]);+ const [stamped] = await engine.executeRaw<{ expired: boolean }>('SELECT expired_at IS NOT NULL AS expired FROM facts WHERE id = $1', [w!.id]);+ expect({ fact, page, take, withdrawn: stamped!.expired ? 'expired' : 'active' })+ .toEqual({ fact: 'purged_content', page: 'purged_content', take: 'purged_content', withdrawn: 'expired' });+ } finally {+ for (const ledger of SHADOWED) await engine.executeRaw(`DROP TABLE IF EXISTS pg_temp.${ledger}`);+ }+ });+});diff --git a/test/guard-definer-pglite.test.ts b/test/guard-definer-pglite.test.tsdeleted file mode 100644index 513e498002..0000000000--- a/test/guard-definer-pglite.test.ts+++ /dev/null@@ -1,53 +0,0 @@-/**- * #7632 on PGLite: one role, so the guards read every ledger row either way, but the catalog matches Postgres (the- * guards are definers with pg_temp last on their path, the raising guard triggers fire AFTER ROW, the derivation guard's- * BEFORE ROW drop is joined by its AFTER ROW check, every pinned search_path ends in pg_temp) and an AFTER ROW guard still refuses the write in the same statement.- */-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';-import { PGLiteEngine } from '../src/core/pglite-engine.ts';-import { DEFINER_GUARDS, GUARD_SEARCH_PATH } from '../src/core/guard-definer.ts';--describe('purge and withdrawal guard catalog on PGLite (#7632)', () => {- let engine: PGLiteEngine;- beforeAll(async () => {- engine = new PGLiteEngine();- await engine.connect({});- await engine.initSchema();- }, 120_000);- afterAll(async () => { await engine?.disconnect(); });-- test('guards are SECURITY DEFINER pinned with pg_temp last, and not executable by PUBLIC', async () => {- const rows = await engine.executeRaw<{ fn: string; secdef: boolean; config: string[] | null; public_execute: boolean }>(- `SELECT p.proname AS fn, p.prosecdef AS secdef, p.proconfig AS config,- EXISTS (SELECT 1 FROM aclexplode(COALESCE(p.proacl, acldefault('f', p.proowner))) a WHERE a.grantee = 0 AND a.privilege_type = 'EXECUTE') AS public_execute- FROM pg_proc p WHERE p.oid = ANY(SELECT to_regprocedure(g || '()') FROM unnest($1::text[]) g) ORDER BY 1`, [DEFINER_GUARDS.map(g => g.fn)]);- expect(rows).toEqual([...DEFINER_GUARDS].map(g => g.fn).sort().map(fn => ({ fn, secdef: true, config: [`search_path=${GUARD_SEARCH_PATH}`], public_execute: false })));- });-- test('the raising guards fire AFTER ROW and the derivation guard drops BEFORE ROW and checks AFTER ROW', async () => {- const rows = await engine.executeRaw<{ trigger: string; timing: string }>(- `SELECT tgname AS trigger, CASE WHEN (tgtype & 2) <> 0 THEN 'BEFORE' ELSE 'AFTER' END AS timing FROM pg_trigger WHERE NOT tgisinternal- AND tgname IN ('facts_refuse_purged', 'takes_refuse_purged', 'pages_refuse_purged', 'page_segment_derivations_refuse_purging', 'page_segment_derivations_refuse_stored_purging') ORDER BY 1`);- expect(rows).toEqual([- { trigger: 'facts_refuse_purged', timing: 'AFTER' },- { trigger: 'page_segment_derivations_refuse_purging', timing: 'BEFORE' },- { trigger: 'page_segment_derivations_refuse_stored_purging', timing: 'AFTER' },- { trigger: 'pages_refuse_purged', timing: 'AFTER' },- { trigger: 'takes_refuse_purged', timing: 'AFTER' },- ]);- });-- test('every function that pins a search_path ends it with pg_temp', async () => {- const rows = await engine.executeRaw<{ sig: string }>(- `SELECT p.oid::regprocedure::text AS sig FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace CROSS JOIN LATERAL unnest(p.proconfig) AS s(setting)- WHERE n.nspname = 'public' AND s.setting LIKE 'search_path=%' AND s.setting NOT LIKE '%, pg_temp' ORDER BY 1`);- expect(rows.map(r => r.sig)).toEqual([]);- });-- test('an AFTER ROW guard still refuses purged page content and leaves no row', async () => {- await engine.executeRaw(`INSERT INTO page_purges (source_id, content_hash, slug) VALUES ('default', 'deadbeefcafe00000000000000000002', 'notes/purged-example')`);- await expect(engine.executeRaw(`INSERT INTO pages (slug, type, title, compiled_truth, content_hash)- VALUES ('notes/again-example', 'note', 't', 'x', 'deadbeefcafe00000000000000000002')`)).rejects.toThrow('purged_content: this page content was purged');- expect(await engine.executeRaw(`SELECT 1 FROM pages WHERE slug = 'notes/again-example'`)).toEqual([]);- });-});diff --git a/test/guard-definer-source.test.ts b/test/guard-definer-source.test.tsdeleted file mode 100644index 98288b82ab..0000000000--- a/test/guard-definer-source.test.ts+++ /dev/null@@ -1,55 +0,0 @@-/**- * #7632: the seven purge and withdrawal guards are SECURITY DEFINER from migration v276 on. A CREATE OR REPLACE of one- * of them resets SECURITY DEFINER and its search_path to whatever the statement says, so a later definition must carry- * both. The only definitions without them are the frozen modules the migrations before v276 apply (v276 then makes the- * functions definers), and those modules may not be imported by anything else.- */-import { describe, expect, test } from 'bun:test';-import { readdirSync, readFileSync, statSync } from 'node:fs';-import { join, relative, resolve } from 'node:path';-import { DEFINER_GUARDS, GUARD_SEARCH_PATH } from '../src/core/guard-definer.ts';--const REPO = resolve(import.meta.dir, '..');-const FROZEN = ['src/core/facts/purge-schema.ts', 'src/core/facts/insert-guard-schema.ts', 'src/core/facts/withdrawal-schema.ts'];-const DEFINER_MIGRATION = 276;--function files(dir: string): string[] {- return readdirSync(dir).flatMap(name => {- const path = join(dir, name);- return statSync(path).isDirectory() ? files(path) : path.endsWith('.ts') ? [path] : [];- });-}--const sources = files(join(REPO, 'src')).map(path => ({ path: relative(REPO, path), text: readFileSync(path, 'utf8') }));--describe('guard definitions keep SECURITY DEFINER (#7632)', () => {- test('every CREATE OR REPLACE of a guard outside the frozen pre-v276 modules is SECURITY DEFINER with the pinned path', () => {- const offenders: string[] = [];- for (const { path, text } of sources) {- if (FROZEN.includes(path)) continue;- for (const { fn } of DEFINER_GUARDS) {- for (const match of text.matchAll(new RegExp(`CREATE OR REPLACE FUNCTION ${fn}\\(\\)[\\s\\S]*?\\bAS \\$`, 'g'))) {- const header = match[0].replaceAll(/\$\{GUARD_SEARCH_PATH\}/g, GUARD_SEARCH_PATH);- if (!header.includes('SECURITY DEFINER') || !header.includes(`search_path = ${GUARD_SEARCH_PATH}`)) offenders.push(`${path}: ${fn}`);- }- }- }- expect(offenders).toEqual([]);- });-- test('the frozen modules that define guards without SECURITY DEFINER are imported only by migrations before v276', () => {- const importers: string[] = [];- for (const { path, text } of sources) {- for (const frozen of FROZEN) {- const name = frozen.split('/').pop()!.replace('.ts', '');- if (!new RegExp(`from '[^']*/${name}\\.ts'`).test(text)) continue;- const version = /schema-migrations\/v(\d+)-/.exec(path)?.[1];- if (version !== undefined && Number(version) < DEFINER_MIGRATION) continue;- // Importing a constant that is not a guard definition is fine.- const imported = new RegExp(`import \\{([^}]*)\\} from '[^']*/${name}\\.ts'`).exec(text)?.[1] ?? '';- if (/MEMORY_PURGE_GUARD_SQL|FACT_INSERT_GUARD_SQL|FACT_WITHDRAWAL_SCHEMA_(SQL|STATEMENTS)|FACT_WITHDRAWAL_NORMALIZED_SQL/.test(imported)) importers.push(`${path} imports ${imported.trim()}`);- }- }- expect(importers).toEqual([]);- });-});