Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
fix(databases): trace read causes and refresh failures (#7411)
Wolf Mermelstein37f606475cc6
diff --git a/apps/web/src/features/block-database/context/table-source.ts b/apps/web/src/features/block-database/context/table-source.tsindex cf015e8102..415c1025ea 100644--- a/apps/web/src/features/block-database/context/table-source.ts+++ b/apps/web/src/features/block-database/context/table-source.ts@@ -36,7 +36,9 @@ export type DatabaseRowsSource = {loading: Accessor<boolean>;refreshing: Accessor<boolean>;error: Accessor<DatabaseReadFailure | undefined>;- refresh(): ResultAsync<void, DatabaseReadFailure>;+ refresh(+ reason?: 'after-write' | 'refresh'+ ): ResultAsync<void, DatabaseReadFailure>;/*** `inferenceBaseVersion` is the table version a new column's type is* settled against from its first value; ops themselves carry no version.diff --git a/apps/web/src/features/block-database/primitives/table-controller.ts b/apps/web/src/features/block-database/primitives/table-controller.tsindex 459bcf6a81..697dbde945 100644--- a/apps/web/src/features/block-database/primitives/table-controller.ts+++ b/apps/web/src/features/block-database/primitives/table-controller.ts@@ -159,7 +159,7 @@ export function createTableController(if (written.isErr()) {const failure = written.error;const outcomeUnknown = failure.kind === 'outcome-unknown';- if (outcomeUnknown && (await source.refresh()).isErr())+ if (outcomeUnknown && (await source.refresh('after-write')).isErr())setRefreshWarning(true);const failed: FailedWrite = {mutation,@@ -216,7 +216,9 @@ export function createTableController(});// A failed refresh cannot turn a committed write into a failed edit.span.event('committed_state_applied');- await span.span('database.rows.refresh', async () => refresh());+ await span.span('database.rows.refresh', async () =>+ refresh('after-write')+ );span.event('refresh_completed');return ok(saved);})@@ -261,8 +263,8 @@ export function createTableController();}- async function refresh() {- const refreshed = await source.refresh();+ async function refresh(reason: 'after-write' | 'refresh' = 'refresh') {+ const refreshed = await source.refresh(reason);setRefreshWarning(refreshed.isErr());if (refreshed.isOk()) pruneCommitted();}@@ -277,7 +279,7 @@ export function createTableController(return await writes.run(TABLE_WRITES, async () => {const added = await source.addOption(columnId, label);// The option is saved even if its subsequent rows refresh fails.- if (added.isOk()) await refresh();+ if (added.isOk()) await refresh('after-write');return added;});} finally {@@ -359,7 +361,7 @@ export function createTableController(drain: (writes: AcceptedDraftWrites) => Promise<boolean>) => (disposed ? Promise.resolve(false) : drain({ save })),retry,- refresh,+ refresh: () => refresh(),addGroup: (...request: Parameters<typeof addGroup>): ReturnType<typeof addGroup> =>diff --git a/apps/web/src/features/block-database/queries/table-rows.ts b/apps/web/src/features/block-database/queries/table-rows.tsindex 15ff2f71f4..d346e29f54 100644--- a/apps/web/src/features/block-database/queries/table-rows.ts+++ b/apps/web/src/features/block-database/queries/table-rows.ts@@ -1,5 +1,6 @@import { databaseSqlSchema } from '@core/database-sql/catalog';import type { DatabaseOp } from '@core/database-sql/generated/types';+import type { DatabaseSqlReadReason } from '@core/database-sql/trace';import { type ResultError, thrownResultErrorHasCode } from '@core/util/result';import { Telemetry } from '@macro-inc/observability';import {@@ -308,32 +309,42 @@ export function createDatabaseRowsSource(props: {* Read from the network again; what comes back is at least `version`. A* read a later one replaced shows nothing, so it leaves the version alone.*/- function readAgain(version: number): ResultAsync<void, DatabaseReadFailure> {+ function readAgain(+ version: number,+ reason: DatabaseSqlReadReason+ ): ResultAsync<void, DatabaseReadFailure> {return ResultAsync.combine([- rowsQuery.refresh(),+ rowsQuery.refresh(reason),retainedRowIds().length- ? retainedQuery.refresh()+ ? retainedQuery.refresh(reason): okAsync<DatabaseSqlRun>({ landed: true }),]).map(([rows, retained]) => {if (rows.landed && retained.landed)setReadVersion((previous) => Math.max(previous, version));});}- function refresh(): ResultAsync<void, DatabaseReadFailure> {- const failed = rowsQuery.error();- const schema =- failed && isStaleSchema(failed) ? refreshSchema() : okAsync(undefined);+ function refresh(+ reason: 'after-write' | 'refresh' = 'refresh'+ ): ResultAsync<void, DatabaseReadFailure> {const span = Telemetry.span('database.rows.read_refresh');span.setAttr('database.id', props.databaseId);span.setAttr('database.table_id', tableId);- const reading = span.run(() =>- schema.andThen(() => {+ span.setAttr('database.read_reason', reason);+ const reading = span.run(() => {+ const failed = rowsQuery.error();+ const staleSchema = failed && isStaleSchema(failed);+ const schema = staleSchema ? refreshSchema() : okAsync(undefined);+ span.setAttr('database.refresh_schema', Boolean(staleSchema));+ return schema.andThen(() => {const table = currentTable();return table- ? readAgain(table.table.version)+ ? readAgain(+ table.table.version,+ staleSchema ? 'schema-change' : reason+ ): errAsync<void, DatabaseReadFailure>(TABLE_UNAVAILABLE);- })- );+ });+ });return reading.andTee(() => {span.setAttr('database.outcome', 'success');@@ -342,15 +353,19 @@ export function createDatabaseRowsSource(props: {.orTee((failure) => {span.setAttr('database.outcome', 'error');span.setAttr('database.error_kind', failure.kind);- span.error(JSON.stringify(failure));- Telemetry.warn('database rows could not be refreshed', {- databaseId: props.databaseId,- tableId,- failure: JSON.stringify(failure),- });+ span.error(failure.kind);+ span.run(() =>+ Telemetry.warn('database rows could not be refreshed', {+ databaseId: props.databaseId,+ tableId,+ reason,+ failureKind: failure.kind,+ })+ );span.end();});}+/** Read these rows again by id, through the engine, into the cache the view reads. */function readRows(rowIds: string[]): ResultAsync<void, DatabaseReadFailure> {const detail = cachedDetail();@@ -362,7 +377,8 @@ export function createDatabaseRowsSource(props: {scope: props.databaseId,sql: rowsByIdStatement(table.sql_name, rowIds),},- props.read+ props.read,+ 'websocket').map(() => undefined);}/** Answer the open reads from the cache rows were read into; at least `version` once they land. */@@ -384,7 +400,7 @@ export function createDatabaseRowsSource(props: {props.onTableChanged((version) => {if (version <= Math.max(readVersion(), writtenVersion)) return;const target = Math.max(version, currentTable()?.table.version ?? version);- const fullRead = () => readAgain(target);+ const fullRead = () => readAgain(target, 'websocket');refreshInBackground({// Rows read by id reach the view only through a local cache; without one, read whole.refresh: () =>diff --git a/apps/web/src/lib/core/database-sql/driver.ts b/apps/web/src/lib/core/database-sql/driver.tsindex 630da7b834..c6d25a7517 100644--- a/apps/web/src/lib/core/database-sql/driver.ts+++ b/apps/web/src/lib/core/database-sql/driver.ts@@ -14,6 +14,7 @@ import type {Step,} from './generated/types';import {+ type DatabaseSqlReadContext,type DatabaseSqlRunTrace,type DatabaseSqlStepTrace,traceDatabaseSqlRun,@@ -176,10 +177,14 @@ export function runDatabaseSql({source,open = openDatabaseSqlQuery,- }: { source: RowSource; open?: OpenEngine }+ context,+ }: { source: RowSource; open?: OpenEngine; context?: DatabaseSqlReadContext }): ResultAsync<Outcome, DatabaseSqlFailure> {- return traceDatabaseSqlRun({ kind: 'sql', sql }, catalog, (trace) =>- drive(() => open(catalog, sql), source, trace)+ return traceDatabaseSqlRun(+ { kind: 'sql', sql },+ catalog,+ (trace) => drive(() => open(catalog, sql), source, trace),+ context);}@@ -190,10 +195,14 @@ export function runDatabaseView({source,open = openDatabaseViewQuery,- }: { source: RowSource; open?: OpenView }+ context,+ }: { source: RowSource; open?: OpenView; context?: DatabaseSqlReadContext }): ResultAsync<Outcome, DatabaseSqlFailure> {- return traceDatabaseSqlRun({ kind: 'view', view }, catalog, (trace) =>- drive(() => open(catalog, view), source, trace)+ return traceDatabaseSqlRun(+ { kind: 'view', view },+ catalog,+ (trace) => drive(() => open(catalog, view), source, trace),+ context);}diff --git a/apps/web/src/lib/core/database-sql/trace.test.ts b/apps/web/src/lib/core/database-sql/trace.test.tsindex 548d9b283a..b54ed8a1bb 100644--- a/apps/web/src/lib/core/database-sql/trace.test.ts+++ b/apps/web/src/lib/core/database-sql/trace.test.ts@@ -1,4 +1,4 @@-import { ok, okAsync } from 'neverthrow';+import { errAsync, ok, okAsync } from 'neverthrow';import { afterEach, describe, expect, it, vi } from 'vitest';import type { Catalog, Outcome } from './generated/types';import { traceDatabaseSqlRun } from './trace';@@ -10,7 +10,10 @@ type RecordedSpan = {ended: boolean;};-const recorded = vi.hoisted(() => ({ roots: [] as RecordedSpan[] }));+const recorded = vi.hoisted(() => ({+ roots: [] as RecordedSpan[],+ warnings: vi.fn(),+}));vi.mock('@macro-inc/observability', () => {const fake = (node: RecordedSpan) => ({@@ -35,6 +38,7 @@ vi.mock('@macro-inc/observability', () => {});return {Telemetry: {+ warn: recorded.warnings,span: (name: string) => {const root = { name, attributes: {}, children: [], ended: false };recorded.roots.push(root);@@ -46,6 +50,7 @@ vi.mock('@macro-inc/observability', () => {afterEach(() => {recorded.roots.length = 0;+ recorded.warnings.mockClear();vi.restoreAllMocks();});@@ -188,4 +193,64 @@ describe('database SQL run traces', () => {],]);});+ it('logs failed reads with their cause and IDs without SQL or error content', async () => {+ const result = await traceDatabaseSqlRun(+ { kind: 'sql', sql: "SELECT 'private cell value' FROM Guests" },+ catalog,+ () => errAsync({ kind: 'fetch', message: 'private cell value' }),+ { reason: 'after-write', scope: 'party', requestPolicy: 'network-only' }+ );+ expect(result.isErr()).toBe(true);+ expect(recorded.roots[0].attributes).toMatchObject({+ 'database_sql.read_reason': 'after-write',+ 'database_sql.request_policy': 'network-only',+ 'database_sql.scope_id': 'party',+ });+ expect(recorded.warnings).toHaveBeenCalledWith('database SQL read failed', {+ 'database_sql.error_kind': 'fetch',+ 'database_sql.read_reason': 'after-write',+ 'database_sql.request_policy': 'network-only',+ 'database_sql.scope_id': 'party',+ 'database_sql.database_ids': 'party',+ 'database_sql.table_ids': 'guests',+ });+ expect(JSON.stringify(recorded.warnings.mock.calls)).not.toContain(+ 'private cell value'+ );+ expect(recorded.roots[0].ended).toBe(true);+ });++ it('keeps an expected cache warmup miss out of failure logs', async () => {+ await traceDatabaseSqlRun(+ { kind: 'sql', sql: 'SELECT Name FROM Guests' },+ catalog,+ () => errAsync({ kind: 'fetch' }),+ { reason: 'initial', requestPolicy: 'cache-only', reportFailure: false }+ );+ expect(recorded.warnings).not.toHaveBeenCalled();+ expect(recorded.roots[0].ended).toBe(true);+ });+ it('records structural engine error codes without the unknown column value', async () => {+ await traceDatabaseSqlRun(+ { kind: 'sql', sql: 'SELECT confidential FROM Guests' },+ catalog,+ () =>+ errAsync({+ kind: 'engine',+ error: {+ stage: 'view' as const,+ kind: 'unknownColumn' as const,+ column: 'confidential',+ },+ }),+ { reason: 'schema-change', requestPolicy: 'network-only' }+ );+ expect(recorded.roots[0].attributes).toMatchObject({+ 'database_sql.error_stage': 'view',+ 'database_sql.error_code': 'unknownColumn',+ });+ expect(JSON.stringify(recorded.warnings.mock.calls)).not.toContain(+ 'confidential'+ );+ });});diff --git a/apps/web/src/lib/core/database-sql/trace.ts b/apps/web/src/lib/core/database-sql/trace.tsindex a6111bbf58..c3ef05fa14 100644--- a/apps/web/src/lib/core/database-sql/trace.ts+++ b/apps/web/src/lib/core/database-sql/trace.ts@@ -11,6 +11,7 @@ import type {DatabaseView,Outcome,Request,+ RunError,} from './generated/types';const PREFIX = '[database-sql]';@@ -23,6 +24,26 @@ export type DatabaseSqlSubject =| { kind: 'check'; sql: string }| { kind: 'view'; view: DatabaseView };+/** Why the caller is reading; contains no statement or cell content. */+export type DatabaseSqlReadReason =+ | 'initial'+ | 'statement-change'+ | 'schema-change'+ | 'refresh'+ | 'after-write'+ | 'websocket'+ | 'cache-change'+ | 'cache-reconcile'+ | 'read';++export type DatabaseSqlReadContext = {+ reason: DatabaseSqlReadReason;+ scope?: string;+ requestPolicy: string;+ /** An initial cache-only miss is expected, not a failed network read. */+ reportFailure?: boolean;+};+/** What a row source tells a step about the GraphQL request it sends. */export interface DatabaseSqlStepTrace {request(document: string, variables: unknown): void;@@ -119,6 +140,7 @@ function subjectAttributes(span: Span, subject: DatabaseSqlSubject) {).with({ kind: 'view' }, ({ view }) => {span.setAttr('database_sql.view_id', view.id);+ span.setAttr('database_sql.table_id', view.tableId);span.setAttr('database_sql.view_name', view.name);}).exhaustive();@@ -165,14 +187,22 @@ function logStep(step: DatabaseSqlStepRecord, tableNames: Map<string, string>) {* Run `drive` inside a `database_sql.run` span, giving it a trace whose* fetches and folds are child spans, then log the run as one group.*/-export function traceDatabaseSqlRun<Failure extends { kind: string }>(+export function traceDatabaseSqlRun<+ Failure extends { kind: string; error?: RunError },+>(subject: DatabaseSqlSubject,catalog: Catalog,- drive: (trace: DatabaseSqlRunTrace) => ResultAsync<Outcome, Failure>+ drive: (trace: DatabaseSqlRunTrace) => ResultAsync<Outcome, Failure>,+ context?: DatabaseSqlReadContext): ResultAsync<Outcome, Failure> {const started = performance.now();const runSpan = Telemetry.span('database_sql.run');subjectAttributes(runSpan, subject);+ if (context) {+ runSpan.setAttr('database_sql.read_reason', context.reason);+ runSpan.setAttr('database_sql.request_policy', context.requestPolicy);+ if (context.scope) runSpan.setAttr('database_sql.scope_id', context.scope);+ }runSpan.setAttr('database_sql.database_ids',[...new Set(catalog.tables.map((table) => table.databaseId))].join(',')@@ -291,8 +321,37 @@ export function traceDatabaseSqlRun<Failure extends { kind: string }>();}).orTee((failure) => {+ const engineError = failure.error;+ const detail = {+ ...(engineError+ ? { 'database_sql.error_stage': engineError.stage }+ : {}),+ ...(engineError?.stage === 'resolve' || engineError?.stage === 'view'+ ? { 'database_sql.error_code': engineError.kind }+ : {}),+ };+ for (const [key, value] of Object.entries(detail))+ runSpan.setAttr(key, value);runSpan.setAttr('database_sql.error_kind', failure.kind);runSpan.error(JSON.stringify(failure));+ // Error messages may contain SQL literals or cell values. The error kind+ // and target IDs locate the failed trace without exporting that content.+ if (context && context.reportFailure !== false)+ runSpan.run(() =>+ Telemetry.warn('database SQL read failed', {+ ...detail,+ 'database_sql.error_kind': failure.kind,+ 'database_sql.read_reason': context.reason,+ 'database_sql.request_policy': context.requestPolicy,+ 'database_sql.scope_id': context.scope ?? '',+ 'database_sql.database_ids': [+ ...new Set(catalog.tables.map((table) => table.databaseId)),+ ].join(','),+ 'database_sql.table_ids': catalog.tables+ .map((table) => table.id)+ .join(','),+ })+ );finish({ error: failure.kind }, failure);});}diff --git a/apps/web/src/lib/queries/database-sql/create-database-sql-query.test.ts b/apps/web/src/lib/queries/database-sql/create-database-sql-query.test.tsindex 95a059409d..9b61e6885b 100644--- a/apps/web/src/lib/queries/database-sql/create-database-sql-query.test.ts+++ b/apps/web/src/lib/queries/database-sql/create-database-sql-query.test.ts@@ -6,6 +6,7 @@ import type {Schema,Step,} from '@core/database-sql/generated/types';+import * as sqlTrace from '@core/database-sql/trace';import type { CacheHost } from '@graphql-cache/host/types';import type {CacheRevision,@@ -380,6 +381,7 @@ describe('createDatabaseSqlQuery', () => {});it('refreshes from the network, and a failed refresh fails as a fetch and keeps the answer', async () => {+ const traced = vi.spyOn(sqlTrace, 'traceDatabaseSqlRun');const policies: string[] = [];let failing = false;const exchange: Exchange = () => (incoming) =>@@ -426,9 +428,9 @@ describe('createDatabaseSqlQuery', () => {expect(query.outcome()?.rows).toEqual([[{ type: 'text', value: 'Acme' }]]));- expect(await query.refresh()).toEqual(ok({ landed: true }));+ expect(await query.refresh('after-write')).toEqual(ok({ landed: true }));failing = true;- expect((await query.refresh())._unsafeUnwrapErr()).toEqual({+ expect((await query.refresh('after-write'))._unsafeUnwrapErr()).toEqual({kind: 'fetch',message: '[Network] offline',});@@ -443,6 +445,11 @@ describe('createDatabaseSqlQuery', () => {message: '[Network] offline',});expect(query.outcome()?.rows).toEqual([[{ type: 'text', value: 'Acme' }]]);+ expect(traced.mock.calls.map((call) => call[3]?.reason)).toEqual([+ 'initial',+ 'after-write',+ 'after-write',+ ]);});it('keeps a refresh from the network when the cache changes while it is in flight', async () => {diff --git a/apps/web/src/lib/queries/database-sql/create-database-sql-query.ts b/apps/web/src/lib/queries/database-sql/create-database-sql-query.tsindex 3e469cbb25..b69a7e4d87 100644--- a/apps/web/src/lib/queries/database-sql/create-database-sql-query.ts+++ b/apps/web/src/lib/queries/database-sql/create-database-sql-query.ts@@ -19,6 +19,10 @@ import type {Outcome,Schema,} from '@core/database-sql/generated/types';+import type {+ DatabaseSqlReadContext,+ DatabaseSqlReadReason,+} from '@core/database-sql/trace';import { buildDatabaseSqlCatalog } from '@core/database-sql/wasm-module';import { idToDisplayName, idToEmail } from '@core/user/util';import type { CacheHost } from '@graphql-cache/host/types';@@ -99,15 +103,18 @@ function runStatement(catalog: Catalog,statement: DatabaseSqlStatement,source: RowSource,- capabilities: Pick<DatabaseSqlQueryCapabilities, 'open' | 'openView'>+ capabilities: Pick<DatabaseSqlQueryCapabilities, 'open' | 'openView'>,+ context: DatabaseSqlReadContext): ResultAsync<Outcome, DatabaseSqlFailure> {if (statement.view)return runDatabaseView(catalog, statement.view, {source,+ context,...(capabilities.openView ? { open: capabilities.openView } : {}),});return runDatabaseSql(catalog, statement.sql, {source,+ context,...(capabilities.open ? { open: capabilities.open } : {}),});}@@ -124,7 +131,9 @@ export interface DatabaseSqlQuery {error: Accessor<DatabaseSqlFailure | undefined>;loading: Accessor<boolean>;/** Read the statement's tables from the server again. */- refresh: () => ResultAsync<DatabaseSqlRun, DatabaseSqlFailure>;+ refresh: (+ reason?: DatabaseSqlReadReason+ ) => ResultAsync<DatabaseSqlRun, DatabaseSqlFailure>;/** Whether a local cache backs the reads, so rows read into it can answer the statement. */cached: () => boolean;/** Answer the statement again from the local cache, as a cache change would, without waiting on one. */@@ -167,6 +176,7 @@ export function createDatabaseSqlQuery(current: DatabaseSqlStatement,requestPolicy: RequestPolicy,reconcile: boolean,+ reason: DatabaseSqlReadReason,options: { reportFailure?: boolean; keepLoading?: boolean } = {}): ResultAsync<DatabaseSqlRun, DatabaseSqlFailure> => {const generation = ++latest;@@ -184,7 +194,13 @@ export function createDatabaseSqlQuery(people: capabilities.people,membership: host ? { host, baselines, reconcile } : undefined,}),- capabilities+ capabilities,+ {+ reason,+ scope: current.scope,+ requestPolicy,+ reportFailure: options.reportFailure,+ }).map((answer): DatabaseSqlRun => {if (generation !== latest) return { landed: false };// A cache change that left the answer alone keeps the same outcome.@@ -223,13 +239,16 @@ export function createDatabaseSqlQuery(return new ResultAsync(settle());}- function openStatement(current: DatabaseSqlStatement): void {+ function openStatement(+ current: DatabaseSqlStatement,+ reason: DatabaseSqlReadReason+ ): void {if (!capabilities.cacheHost()) {- void trackNetwork(run(current, 'cache-and-network', false));+ void trackNetwork(run(current, 'cache-and-network', false, reason));return;}// Only a complete cached answer is shown. A miss still reads the network.- const cached = run(current, 'cache-only', false, {+ const cached = run(current, 'cache-only', false, reason, {reportFailure: false,keepLoading: true,});@@ -237,13 +256,13 @@ export function createDatabaseSqlQuery(const reconcile = async () => {await cached;if (generation !== latest) return ok({ landed: false });- return await run(current, 'network-only', false);+ return await run(current, 'network-only', false, reason);};void trackNetwork(new ResultAsync(reconcile()));}createEffect(- on(statement, (current) => {+ on(statement, (current, previous) => {baselines = new Map();latest += 1;setError(undefined);@@ -255,7 +274,12 @@ export function createDatabaseSqlQuery(});return;}- openStatement(current);+ const reason = !previous+ ? 'initial'+ : JSON.stringify(previous.schema) !== JSON.stringify(current.schema)+ ? 'schema-change'+ : 'statement-change';+ openStatement(current, reason);}));@@ -271,7 +295,7 @@ export function createDatabaseSqlQuery(return;}const current = untrack(statement);- if (current) await run(current, 'cache-first', true);+ if (current) await run(current, 'cache-first', true, 'cache-change');}));});@@ -285,16 +309,16 @@ export function createDatabaseSqlQuery(catalog,error,loading,- refresh: () => {+ refresh: (reason = 'refresh') => {const current = untrack(statement);if (!current) return okAsync({ landed: false });- return trackNetwork(run(current, 'network-only', false));+ return trackNetwork(run(current, 'network-only', false, reason));},cached: () => capabilities.cacheHost() !== undefined,answerFromCache: () => {const current = untrack(statement);if (!current) return okAsync({ landed: false });- return run(current, 'cache-first', true);+ return run(current, 'cache-first', true, 'cache-reconcile');},};}@@ -309,7 +333,8 @@ export function refreshInBackground(reader: {/** One read of a statement from the network, for an answer nothing keeps live. */export function readDatabaseSql(statement: DatabaseSqlStatement,- capabilities: DatabaseSqlQueryCapabilities = productionDatabaseSqlCapabilities()+ capabilities: DatabaseSqlQueryCapabilities = productionDatabaseSqlCapabilities(),+ reason: DatabaseSqlReadReason = 'read'): ResultAsync<{ catalog: Catalog; outcome: Outcome }, DatabaseSqlFailure> {return statementCatalog(statement, capabilities).andThen((catalog) =>runStatement(@@ -321,7 +346,8 @@ export function readDatabaseSql(requestPolicy: 'network-only',people: capabilities.people,}),- capabilities+ capabilities,+ { reason, scope: statement.scope, requestPolicy: 'network-only' }).map((outcome) => ({ catalog, outcome })));}