fuli-context 0.5.0 → 0.7.2

package/src/storage/migrations/002-storage-integrity.sql

@@ -1,113 +0,0 @@
-CREATE TABLE schema_migrations_new (
-  version INTEGER PRIMARY KEY,
-  checksum TEXT NOT NULL,
-  applied_at TEXT NOT NULL
-);
-
-INSERT INTO schema_migrations_new (version, checksum, applied_at)
-SELECT
-  version,
-  CASE version
-    WHEN 1 THEN 'ab393d736d8ff18fde75478002b2b4b3b4d7e906974cd724058e31436fba0ea9'
-  END,
-  applied_at
-FROM schema_migrations;
-
-DROP TABLE schema_migrations;
-ALTER TABLE schema_migrations_new RENAME TO schema_migrations;
-
-CREATE TABLE facts_new (
-  id TEXT PRIMARY KEY,
-  space_id TEXT NOT NULL REFERENCES spaces(id),
-  subject TEXT NOT NULL,
-  predicate TEXT NOT NULL,
-  object TEXT NOT NULL,
-  source_episode_id TEXT NOT NULL REFERENCES episodes(id),
-  status TEXT NOT NULL CHECK (
-    status IN ('confirmed', 'observed', 'suggested', 'rejected', 'deprecated')
-  ),
-  confidence REAL NOT NULL DEFAULT 1.0 CHECK (
-    typeof(confidence) IN ('integer', 'real') AND confidence >= 0.0 AND confidence <= 1.0
-  ),
-  sensitivity TEXT NOT NULL DEFAULT 'normal' CHECK (
-    sensitivity IN ('normal', 'private', 'restricted')
-  ),
-  scope TEXT NOT NULL DEFAULT 'personal' CHECK (scope IN ('personal', 'public')),
-  valid_at TEXT NOT NULL,
-  invalid_at TEXT,
-  replaced_by_fact_id TEXT REFERENCES facts_new(id)
-);
-
-INSERT INTO facts_new (
-  id, space_id, subject, predicate, object, source_episode_id, status,
-  confidence, sensitivity, scope, valid_at, invalid_at, replaced_by_fact_id
-)
-SELECT
-  id, space_id, subject, predicate, object, source_episode_id, status,
-  confidence, sensitivity, scope, valid_at, invalid_at, NULL
-FROM facts;
-
-UPDATE facts_new
-SET replaced_by_fact_id = (
-  SELECT facts.replaced_by_fact_id
-  FROM facts
-  WHERE facts.id = facts_new.id
-);
-
-DROP TABLE facts;
-ALTER TABLE facts_new RENAME TO facts;
-CREATE INDEX facts_current_idx ON facts(space_id, predicate, invalid_at);
-CREATE INDEX facts_source_idx ON facts(source_episode_id);
-
-CREATE TABLE candidates_new (
-  id TEXT PRIMARY KEY,
-  personal_space_id TEXT NOT NULL REFERENCES spaces(id),
-  target_space_id TEXT REFERENCES spaces(id),
-  episode_id TEXT NOT NULL REFERENCES episodes(id),
-  reason TEXT NOT NULL,
-  status TEXT NOT NULL CHECK (
-    status IN ('pending', 'synced', 'personal_only', 'ignored')
-  ),
-  created_at TEXT NOT NULL,
-  decided_at TEXT
-);
-
-INSERT INTO candidates_new (
-  id, personal_space_id, target_space_id, episode_id, reason,
-  status, created_at, decided_at
-)
-SELECT
-  id, personal_space_id, target_space_id, episode_id, reason,
-  status, created_at, decided_at
-FROM candidates;
-
-DROP TABLE candidates;
-ALTER TABLE candidates_new RENAME TO candidates;
-
-CREATE TABLE outbox_new (
-  id TEXT PRIMARY KEY,
-  kind TEXT NOT NULL,
-  aggregate_id TEXT NOT NULL,
-  payload_json TEXT NOT NULL,
-  status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'sent')),
-  attempts INTEGER NOT NULL DEFAULT 0 CHECK (
-    typeof(attempts) = 'integer' AND attempts >= 0
-  ),
-  next_attempt_at TEXT,
-  created_at TEXT NOT NULL,
-  sent_at TEXT,
-  last_error TEXT
-);
-
-INSERT INTO outbox_new (
-  id, kind, aggregate_id, payload_json, status, attempts,
-  next_attempt_at, created_at, sent_at, last_error
-)
-SELECT
-  id, kind, aggregate_id, payload_json, status, attempts,
-  next_attempt_at, created_at, sent_at, last_error
-FROM outbox;
-
-DROP TABLE outbox;
-ALTER TABLE outbox_new RENAME TO outbox;
-CREATE INDEX outbox_pending_idx ON outbox(status, next_attempt_at, created_at);

package/src/storage/record-validation.js

@@ -1,46 +0,0 @@
-import { CandidateStatus, FactScope, FactStatus, Sensitivity } from '../models.js';
-
-const FACT_STATUSES = new Set(Object.values(FactStatus));
-const CANDIDATE_STATUSES = new Set(Object.values(CandidateStatus));
-const SENSITIVITIES = new Set(Object.values(Sensitivity));
-const SCOPES = new Set(Object.values(FactScope));
-const OUTBOX_STATUSES = new Set(['pending', 'sent']);
-
-export function validateFactRecord(fact) {
-  requireMember('fact status', fact.status, FACT_STATUSES);
-  if (
-    typeof fact.confidence !== 'number' ||
-    !Number.isFinite(fact.confidence) ||
-    fact.confidence < 0 ||
-    fact.confidence > 1
-  ) {
-    throw new TypeError('Fact confidence must be between 0 and 1');
-  }
-  requireMember('fact sensitivity', fact.sensitivity, SENSITIVITIES);
-  requireMember('fact scope', fact.scope, SCOPES);
-  return fact;
-}
-
-export function validateCandidateRecord(candidate) {
-  requireMember('candidate status', candidate.status, CANDIDATE_STATUSES);
-  return candidate;
-}
-
-export function validateOutboxRecord(entry) {
-  requireMember('outbox status', entry.status, OUTBOX_STATUSES);
-  if (!Number.isInteger(entry.attempts) || entry.attempts < 0) {
-    throw new TypeError('Outbox attempts must be a nonnegative integer');
-  }
-  return entry;
-}
-
-export function validateSnapshotRecords(snapshot) {
-  for (const fact of snapshot.facts) validateFactRecord(fact);
-  for (const candidate of snapshot.candidates) validateCandidateRecord(candidate);
-  for (const entry of snapshot.outbox) validateOutboxRecord(entry);
-  return snapshot;
-}
-
-function requireMember(label, value, allowed) {
-  if (!allowed.has(value)) throw new TypeError(`Invalid ${label}: ${value}`);
-}

package/src/storage/snapshot-defaults.js

@@ -1,54 +0,0 @@
-import { CandidateStatus, FactStatus, nowIso } from '../models.js';
-import { validateSnapshotRecords } from './record-validation.js';
-
-export function normalizeSnapshot(snapshot = {}, { outbox = [], imports = [] } = {}) {
-  const input = cloneSnapshot(snapshot);
-  const normalized = {
-    spaces: (input.spaces ?? []).map((space) => ({
-      ...space,
-      description: space.description ?? null,
-      createdAt: space.createdAt ?? nowIso()
-    })),
-    subscriptions: (input.subscriptions ?? []).map((subscription) => ({
-      ...subscription,
-      mode: subscription.mode ?? 'latest',
-      createdAt: subscription.createdAt ?? nowIso()
-    })),
-    episodes: (input.episodes ?? []).map((episode) => ({
-      ...episode,
-      sourceUri: episode.sourceUri ?? null,
-      metadata: episode.metadata ?? {},
-      createdAt: episode.createdAt ?? nowIso()
-    })),
-    facts: (input.facts ?? []).map((fact) => ({
-      ...fact,
-      status: fact.status ?? FactStatus.CONFIRMED,
-      confidence: fact.confidence ?? 1,
-      sensitivity: fact.sensitivity ?? 'normal',
-      scope: fact.scope ?? 'personal',
-      validAt: fact.validAt ?? nowIso(),
-      invalidAt: fact.invalidAt ?? null,
-      replacedByFactId: fact.replacedByFactId ?? null
-    })),
-    candidates: (input.candidates ?? []).map(normalizeCandidate),
-    outbox: Object.hasOwn(input, 'outbox') ? input.outbox : cloneSnapshot(outbox),
-    imports: Object.hasOwn(input, 'imports') ? input.imports : cloneSnapshot(imports)
-  };
-  return validateSnapshotRecords(normalized);
-}
-
-export function cloneSnapshot(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-
-function normalizeCandidate(candidate) {
-  const status = candidate.status ?? CandidateStatus.PENDING;
-  const createdAt = candidate.createdAt ?? nowIso();
-  return {
-    ...candidate,
-    targetSpaceId: candidate.targetSpaceId ?? null,
-    status,
-    createdAt,
-    decidedAt: candidate.decidedAt ?? (status === CandidateStatus.PENDING ? null : createdAt)
-  };
-}

package/src/storage/sqlite/candidates-repository.js

@@ -1,84 +0,0 @@
-import { randomUUID } from 'node:crypto';
-
-import { CandidateStatus, nowIso } from '../../models.js';
-import { validateCandidateRecord } from '../record-validation.js';
-import { mapCandidate } from './mapper.js';
-
-export class CandidatesRepository {
-  constructor(db) {
-    this.insertStatement = db.prepare(`
-      INSERT INTO candidates (
-        id, personal_space_id, target_space_id, episode_id, reason,
-        status, created_at, decided_at
-      ) VALUES (
-        @id, @personalSpaceId, @targetSpaceId, @episodeId, @reason,
-        @status, @createdAt, @decidedAt
-      )
-    `);
-    this.getStatement = db.prepare('SELECT * FROM candidates WHERE id = ?');
-    this.listStatement = db.prepare('SELECT * FROM candidates ORDER BY rowid');
-    this.pendingStatement = db.prepare(`
-      SELECT * FROM candidates
-      WHERE personal_space_id = ? AND status = 'pending'
-      ORDER BY rowid
-    `);
-    this.updateStatusStatement = db.prepare(`
-      UPDATE candidates SET status = ?, decided_at = ? WHERE id = ?
-    `);
-    this.deleteStatement = db.prepare('DELETE FROM candidates');
-  }
-
-  add(candidate) {
-    if (candidate.id && this.get(candidate.id)) {
-      throw new Error(`Duplicate candidate id: ${candidate.id}`);
-    }
-
-    const status = candidate.status ?? CandidateStatus.PENDING;
-    const createdAt = candidate.createdAt ?? nowIso();
-    const stored = {
-      id: candidate.id || randomUUID(),
-      personalSpaceId: candidate.personalSpaceId,
-      targetSpaceId: candidate.targetSpaceId ?? null,
-      episodeId: candidate.episodeId,
-      reason: candidate.reason,
-      status,
-      createdAt,
-      decidedAt: candidate.decidedAt ?? (
-        status === CandidateStatus.PENDING ? null : createdAt
-      )
-    };
-    validateCandidateRecord(stored);
-    this.insertStatement.run(stored);
-    return this.get(stored.id);
-  }
-
-  get(id) {
-    return mapCandidate(this.getStatement.get(id));
-  }
-
-  list() {
-    return this.listStatement.all().map(mapCandidate);
-  }
-
-  pending(personalSpaceId) {
-    return this.pendingStatement.all(personalSpaceId).map(mapCandidate);
-  }
-
-  updateStatus(id, status) {
-    const candidate = this.get(id);
-    if (!candidate) throw new Error(`Candidate not found: ${id}`);
-    const decidedAt = status === CandidateStatus.PENDING ? null : nowIso();
-    validateCandidateRecord({ ...candidate, status, decidedAt });
-    this.updateStatusStatement.run(status, decidedAt, id);
-    return this.get(id);
-  }
-
-  insertSnapshot(candidate) {
-    validateCandidateRecord(candidate);
-    this.insertStatement.run(candidate);
-  }
-
-  deleteAll() {
-    this.deleteStatement.run();
-  }
-}

package/src/storage/sqlite/episode-evidence-repository.js

@@ -1,154 +0,0 @@
-import {
-  MAX_EPISODE_METADATA_BYTES,
-  MAX_EPISODE_METADATA_FIELD_BYTES,
-  normalizeCorrectionEvidencePreviewOptions,
-  normalizeEvidencePreviewOptions,
-  previewEpisode
-} from '../episode-evidence-preview.js';
-import { sqliteEpisodeRestrictedSql } from './episode-privacy-sql.js';
-
-export class EpisodeEvidenceRepository {
-  constructor(db) {
-    this.db = db;
-    this.correctionStatements = new Map();
-    this.sourceStatement = db.prepare(sourceQuery());
-  }
-
-  source(spaceId, episodeId, options = {}) {
-    const normalized = normalizeEvidencePreviewOptions(options);
-    const row = this.sourceStatement.get({
-      spaceId, episodeId,
-      bodyChars: normalized.maxBodyBytes,
-      bodyBytes: normalized.maxBodyBytes,
-      metadataChars: MAX_EPISODE_METADATA_BYTES,
-      metadataBytes: MAX_EPISODE_METADATA_BYTES,
-      includeRestricted: Number(normalized.includeRestricted)
-    });
-    return previewEpisode(mapSourceRow(row), normalized);
-  }
-
-  corrections(spaceId, factIds, options = {}) {
-    const normalized = normalizeCorrectionEvidencePreviewOptions(options);
-    if (factIds.length === 0) return [];
-    const statement = this.#correctionStatement(factIds.length);
-    const parameters = {
-      spaceId,
-      bodyChars: normalized.maxBodyBytes,
-      bodyBytes: normalized.maxBodyBytes,
-      fieldChars: MAX_EPISODE_METADATA_FIELD_BYTES,
-      fieldBytes: MAX_EPISODE_METADATA_FIELD_BYTES,
-      correctionLimit: normalized.maxCorrectionsPerFact,
-      includeRestricted: Number(normalized.includeRestricted)
-    };
-    factIds.forEach((factId, index) => { parameters[`factId${index}`] = factId; });
-    const groups = [...new Set(factIds)].map((factId) => ({
-      factId,
-      episodes: [],
-      truncated: false
-    }));
-    const byFactId = new Map(groups.map((group) => [group.factId, group]));
-    for (const row of statement.all(parameters)) {
-      const group = byFactId.get(row.fact_id);
-      group.episodes.push(previewEpisode(
-        mapCorrectionRow(row),
-        normalized,
-        { correction: true }
-      ));
-      group.truncated = row.correction_count > normalized.maxCorrectionsPerFact;
-    }
-    return groups;
-  }
-
-  #correctionStatement(factCount) {
-    if (!this.correctionStatements.has(factCount)) {
-      this.correctionStatements.set(factCount, this.db.prepare(correctionQuery(factCount)));
-    }
-    return this.correctionStatements.get(factCount);
-  }
-}
-
-function sourceQuery() {
-  return `
-    SELECT id, space_id, source_kind,
-      substr(body, 1, @bodyChars) AS body_preview,
-      length(CAST(body AS BLOB)) > @bodyBytes AS body_truncated,
-      source_uri,
-      substr(metadata_json, 1, @metadataChars) AS metadata_preview,
-      length(CAST(metadata_json AS BLOB)) > @metadataBytes AS metadata_truncated,
-      created_at
-    FROM episodes source
-    WHERE id = @episodeId AND space_id = @spaceId
-      AND (@includeRestricted = 1 OR NOT ${sqliteEpisodeRestrictedSql('source')})
-  `;
-}
-
-function correctionQuery(factCount) {
-  const factIds = Array.from({ length: factCount }, (_, index) => `@factId${index}`).join(', ');
-  const fields = ['kind', 'factId', 'action'];
-  const selected = fields.map((field) => `
-      substr(CAST(json_extract(metadata_json, '$.${field}') AS TEXT), 1, @fieldChars)
-        AS metadata_${field.toLowerCase()}`
-  ).join(',');
-  const clipped = fields.map((field) => `
-      length(CAST(json_extract(metadata_json, '$.${field}') AS BLOB)) > @fieldBytes`
-  ).join(' OR ');
-  return `
-    WITH ranked AS (
-      SELECT correction.rowid AS correction_rowid,
-        json_extract(metadata_json, '$.factId') AS fact_id,
-        row_number() OVER (
-          PARTITION BY json_extract(metadata_json, '$.factId')
-          ORDER BY created_at DESC, correction.rowid DESC
-        ) AS correction_rank,
-        count(*) OVER (
-          PARTITION BY json_extract(metadata_json, '$.factId')
-        ) AS correction_count
-      FROM episodes correction
-      WHERE space_id = @spaceId
-        AND json_extract(metadata_json, '$.kind') = 'lens_correction'
-        AND json_extract(metadata_json, '$.factId') IN (${factIds})
-        AND (@includeRestricted = 1 OR NOT ${sqliteEpisodeRestrictedSql('correction')})
-    )
-    SELECT correction.id, correction.space_id, correction.source_kind,
-      substr(body, 1, @bodyChars) AS body_preview,
-      length(CAST(body AS BLOB)) > @bodyBytes AS body_truncated,
-      source_uri,${selected}, ranked.fact_id, ranked.correction_count,
-      ((${clipped}) OR EXISTS (
-        SELECT 1 FROM json_each(metadata_json)
-        WHERE key NOT IN ('kind', 'factId', 'action')
-      )) AS metadata_truncated,
-      correction.created_at
-    FROM ranked
-    JOIN episodes correction ON correction.rowid = ranked.correction_rowid
-    WHERE ranked.correction_rank <= @correctionLimit
-    ORDER BY ranked.fact_id, ranked.correction_rank
-  `;
-}
-
-function mapSourceRow(row) {
-  if (!row) return null;
-  return mapRow(row, row.metadata_truncated ? {} : JSON.parse(row.metadata_preview));
-}
-
-function mapCorrectionRow(row) {
-  if (!row) return null;
-  const metadata = {};
-  for (const [key, column] of [
-    ['kind', 'metadata_kind'], ['factId', 'metadata_factid'], ['action', 'metadata_action']
-  ]) if (typeof row[column] === 'string') metadata[key] = row[column];
-  return mapRow(row, metadata);
-}
-
-function mapRow(row, metadata) {
-  return {
-    id: row.id,
-    spaceId: row.space_id,
-    sourceKind: row.source_kind,
-    body: row.body_preview,
-    bodyTruncated: row.body_truncated === 1,
-    sourceUri: row.source_uri,
-    metadata,
-    metadataTruncated: row.metadata_truncated === 1,
-    createdAt: row.created_at
-  };
-}

package/src/storage/sqlite/episode-privacy-sql.js

@@ -1,33 +0,0 @@
-import { isRestrictedEpisode } from '../../security/episode-visibility.js';
-
-const FUNCTION_NAME = 'episode_evidence_is_restricted';
-
-export function registerEpisodePrivacyFunction(db) {
-  db.function(
-    FUNCTION_NAME,
-    { deterministic: true },
-    (sourceKind, body, sourceUri, metadataJson) => Number(isRestrictedEpisode({
-      sourceKind,
-      body,
-      sourceUri,
-      metadata: parseMetadata(metadataJson)
-    }))
-  );
-}
-
-export function sqliteEpisodeRestrictedSql(alias) {
-  return `${FUNCTION_NAME}(
-    ${alias}.source_kind,
-    ${alias}.body,
-    ${alias}.source_uri,
-    ${alias}.metadata_json
-  ) = 1`;
-}
-
-function parseMetadata(value) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return { invalidMetadataRestricted: 'password=invalid-metadata' };
-  }
-}

package/src/storage/sqlite/episodes-repository.js

@@ -1,52 +0,0 @@
-import { randomUUID } from 'node:crypto';
-
-import { nowIso } from '../../models.js';
-import { mapEpisode } from './mapper.js';
-
-export class EpisodesRepository {
-  constructor(db) {
-    this.insertStatement = db.prepare(`
-      INSERT INTO episodes (
-        id, space_id, source_kind, body, source_uri, metadata_json, created_at
-      ) VALUES (
-        @id, @spaceId, @sourceKind, @body, @sourceUri, @metadataJson, @createdAt
-      )
-    `);
-    this.getStatement = db.prepare('SELECT * FROM episodes WHERE id = ?');
-    this.listStatement = db.prepare('SELECT * FROM episodes ORDER BY rowid');
-    this.deleteStatement = db.prepare('DELETE FROM episodes');
-  }
-
-  add(spaceId, sourceKind, body, sourceUri = null, metadata = {}) {
-    const episode = {
-      id: randomUUID(),
-      spaceId,
-      sourceKind,
-      body,
-      sourceUri,
-      metadataJson: JSON.stringify(metadata),
-      createdAt: nowIso()
-    };
-    this.insertStatement.run(episode);
-    return this.get(episode.id);
-  }
-
-  get(id) {
-    return mapEpisode(this.getStatement.get(id));
-  }
-
-  list() {
-    return this.listStatement.all().map(mapEpisode);
-  }
-
-  insertSnapshot(episode) {
-    this.insertStatement.run({
-      ...episode,
-      metadataJson: JSON.stringify(episode.metadata)
-    });
-  }
-
-  deleteAll() {
-    this.deleteStatement.run();
-  }
-}

package/src/storage/sqlite/fact-search-repository.js

@@ -1,162 +0,0 @@
-import { isRestrictedFact } from '../../security/fact-visibility.js';
-import { searchTextSortKey } from '../fact-search-order.js';
-import { sqliteEpisodeRestrictedSql } from './episode-privacy-sql.js';
-import { mapFact } from './mapper.js';
-
-export class FactSearchRepository {
-  constructor(db) {
-    this.db = db;
-    this.statements = new Map();
-    this.omissionStatements = new Map();
-    registerSearchFunctions(db);
-  }
-
-  search(spaceIds, query, {
-    includeHistorical = false,
-    scope = null,
-    limit = null,
-    excludeRestricted = false,
-    safeSourceSpaceId = null,
-    maxObjectBytes = null
-  } = {}) {
-    return this.searchPage(spaceIds, query, {
-      includeHistorical,
-      scope,
-      limit,
-      excludeRestricted,
-      safeSourceSpaceId,
-      maxObjectBytes
-    }).facts;
-  }
-
-  searchPage(spaceIds, query, options = {}) {
-    const {
-      includeHistorical = false,
-      scope = null,
-      limit = null,
-      excludeRestricted = false,
-      safeSourceSpaceId = null,
-      maxObjectBytes = null
-    } = options;
-    if (spaceIds.length === 0) return { facts: [], objectLimitTruncated: false };
-    if (limit !== null && (!Number.isInteger(limit) || limit <= 0)) {
-      throw new TypeError('Fact search limit must be a positive integer');
-    }
-
-    const shape = {
-      spaceCount: spaceIds.length,
-      includeHistorical,
-      scoped: scope !== null,
-      limited: limit !== null,
-      excludeRestricted: excludeRestricted === true,
-      safeSourceRequired: safeSourceSpaceId !== null,
-      objectBytesBounded: maxObjectBytes !== null
-    };
-    const parameters = [...spaceIds];
-    if (scope !== null) parameters.push(scope);
-    if (safeSourceSpaceId !== null) parameters.push(safeSourceSpaceId);
-    if (maxObjectBytes !== null) parameters.push(maxObjectBytes);
-    parameters.push(query.toLowerCase());
-    const factParameters = limit === null ? parameters : [...parameters, limit];
-    const facts = this.#statement(shape).all(...factParameters).map(mapFact);
-    const objectLimitTruncated = maxObjectBytes === null
-      ? false
-      : this.#omissionStatement(shape).pluck().get(...parameters) === 1;
-    return { facts, objectLimitTruncated };
-  }
-
-  #statement(shape) {
-    const key = Object.values(shape).join(':');
-    if (!this.statements.has(key)) {
-      this.statements.set(key, this.db.prepare(buildSearchQuery(shape)));
-    }
-    return this.statements.get(key);
-  }
-
-  #omissionStatement(shape) {
-    const key = Object.values(shape).join(':');
-    if (!this.omissionStatements.has(key)) {
-      this.omissionStatements.set(key, this.db.prepare(buildOmissionQuery(shape)));
-    }
-    return this.omissionStatements.get(key);
-  }
-}
-
-function buildOmissionQuery(shape) {
-  return `SELECT EXISTS (
-    SELECT 1 FROM facts
-    WHERE ${buildWhereClause(shape, { oversized: true })}
-    LIMIT 1
-  )`;
-}
-
-function registerSearchFunctions(db) {
-  db.function('fact_search_text_sort_key', { deterministic: true }, searchTextSortKey);
-  db.function('fact_search_is_restricted', { deterministic: true },
-    (subject, predicate, object, sensitivity) => Number(isRestrictedFact({
-      subject, predicate, object, sensitivity
-    })));
-}
-
-function buildSearchQuery({
-  spaceCount,
-  includeHistorical,
-  scoped,
-  limited,
-  excludeRestricted,
-  safeSourceRequired,
-  objectBytesBounded
-}) {
-  const shape = {
-    spaceCount,
-    includeHistorical,
-    scoped,
-    excludeRestricted,
-    safeSourceRequired,
-    objectBytesBounded
-  };
-  const orderClause = limited
-    ? 'ORDER BY valid_at DESC, fact_search_text_sort_key(id) ASC LIMIT ?'
-    : 'ORDER BY rowid';
-  return `
-    SELECT * FROM facts
-    WHERE ${buildWhereClause(shape)}
-    ${orderClause}
-  `;
-}
-
-function buildWhereClause({
-  spaceCount,
-  includeHistorical,
-  scoped,
-  excludeRestricted,
-  safeSourceRequired,
-  objectBytesBounded
-}, { oversized = false } = {}) {
-  const placeholders = Array.from({ length: spaceCount }, () => '?').join(', ');
-  const currentClause = includeHistorical
-    ? ''
-    : "AND invalid_at IS NULL AND status NOT IN ('rejected', 'deprecated')";
-  const scopeClause = scoped ? 'AND scope = ?' : '';
-  const restrictedClause = excludeRestricted
-    ? `AND fact_search_is_restricted(
-      subject, predicate, object, sensitivity
-    ) = 0`
-    : '';
-  const sourceClause = safeSourceRequired ? `AND EXISTS (
-    SELECT 1 FROM episodes source
-    WHERE source.id = source_episode_id
-      AND source.space_id = ?
-      AND NOT ${sqliteEpisodeRestrictedSql('source')}
-  )` : '';
-  const objectBytesClause = objectBytesBounded
-    ? `AND length(CAST(object AS BLOB)) ${oversized ? '>' : '<='} ?`
-    : '';
-  return `space_id IN (${placeholders})
-      ${currentClause}
-      ${scopeClause}
-      ${restrictedClause}
-      ${sourceClause}
-      ${objectBytesClause}
-      AND instr(lower(subject || ' ' || predicate || ' ' || object), ?) > 0`;
-}