Skip to content

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.md
index 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 the
policies 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 it
runs through this helper and a `LegacyUnscopedRead` when it runs on the pool
diff --git a/docs/guides/rls-and-you.md b/docs/guides/rls-and-you.md
index 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 function
reads 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, so
they call `pg_catalog.`-qualified built-ins instead of pinning a setting (a
diff --git a/llms-full.txt b/llms-full.txt
index 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 the
policies 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 it
runs through this helper and a `LegacyUnscopedRead` when it runs on the pool
diff --git a/scripts/build-schema.ts b/scripts/build-schema.ts
index 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/cor
import { 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.tsv
index 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: link
src/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 row
diff --git a/scripts/structural-suites.tsv b/scripts/structural-suites.tsv
index 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 declared
test/get-page-federated-scope.test.ts #2555 get_chunks federated scope 5 source-surface-helper
test/get-page-federated-scope.test.ts #4275 alias hop scope: archived sources, include_deleted, fuzzy precedence, grant precedence 5 source-surface-helper
test/grant-execution-prerequisites.test.ts execution prerequisite table 1 readFileSync
-test/guard-definer-source.test.ts guard definitions keep SECURITY DEFINER (#7632) 2 readFileSync
test/harness-onboarding.test.ts harness identity and private handoff 6 readFileSync
test/hook-command.serial.test.ts user-prompt 18 source-surface-helper
test/hook-push-spawn-env.test.ts spawnDetachedPush env handoff 2 readFileSync
diff --git a/src/commands/doctor/checks/function-search-path.ts b/src/commands/doctor/checks/function-search-path.ts
new file mode 100644
index 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.ts
deleted file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
deleted file mode 100644
index 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.ts
index 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: st
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 ${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 m
WHERE 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_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();
@@ -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 and
diff --git a/src/core/pglite-schema.generated.ts b/src/core/pglite-schema.generated.ts
index 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\$
DECLARE
src TEXT;
page INTEGER;
@@ -1527,17 +1527,12 @@ BEGIN
src := 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_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();
@@ -1550,13 +1545,13 @@ CREATE TRIGGER pages_derivation_scope_delete AFTER UPDATE OF deleted_at ON pages
CREATE OR REPLACE FUNCTION gbrain_refuse_purging_derivation() RETURNS trigger SET search_path = pg_catalog, public AS \$func\$
BEGIN
IF 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 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
+ WHERE strpos(' ' || replace(translate(gbrain_fact_normalize(s.t), 'ς', 'σ'), 'i̇', 'i') || ' ', k.n) > 0) ELSE false END) ELSE false END) THEN
RETURN NULL;
END IF;
RETURN NEW;
@@ -1565,31 +1560,6 @@ END
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();
-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.ts
index 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\$
DECLARE
src TEXT;
page INTEGER;
@@ -2273,17 +2273,12 @@ BEGIN
src := 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_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();
@@ -2296,13 +2291,13 @@ CREATE TRIGGER pages_derivation_scope_delete AFTER UPDATE OF deleted_at ON pages
CREATE OR REPLACE FUNCTION gbrain_refuse_purging_derivation() RETURNS trigger SET search_path = pg_catalog, public AS \$func\$
BEGIN
IF 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 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
+ WHERE strpos(' ' || replace(translate(gbrain_fact_normalize(s.t), 'ς', 'σ'), 'i̇', 'i') || ' ', k.n) > 0) ELSE false END) ELSE false END) THEN
RETURN NULL;
END IF;
RETURN NEW;
@@ -2311,31 +2306,6 @@ END
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();
-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:schema
DO \$harden\$
DECLARE f RECORD;
BEGIN
@@ -3652,5 +3622,5 @@ BEGIN
EXECUTE 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.ts
index 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.ts
new file mode 100644
index 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.ts
deleted file mode 100644
index 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.sql
index 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$
DECLARE
src TEXT;
page INTEGER;
@@ -2269,17 +2269,12 @@ BEGIN
src := 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_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();
@@ -2292,13 +2287,13 @@ CREATE TRIGGER pages_derivation_scope_delete AFTER UPDATE OF deleted_at ON pages
CREATE OR REPLACE FUNCTION gbrain_refuse_purging_derivation() RETURNS trigger SET search_path = pg_catalog, public AS $func$
BEGIN
IF 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 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
+ WHERE strpos(' ' || replace(translate(gbrain_fact_normalize(s.t), 'ς', 'σ'), 'i̇', 'i') || ' ', k.n) > 0) ELSE false END) ELSE false END) THEN
RETURN 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_derivations
FOR 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:schema
DO $harden$
DECLARE f RECORD;
BEGIN
@@ -3648,4 +3618,4 @@ BEGIN
EXECUTE 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.ts
new file mode 100644
index 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.ts
deleted file mode 100644
index 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.ts
new file mode 100644
index 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.ts
deleted file mode 100644
index 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.ts
index 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.ts
index 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 p
JOIN pg_namespace n ON n.oid = p.pronamespace JOIN pg_language l ON l.oid = p.prolang
WHERE 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.ts
new file mode 100644
index 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.ts
deleted file mode 100644
index 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.ts
deleted file mode 100644
index 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([]);
- });
-});