fuli-context 0.5.0 → 0.7.2

package/src/publication/publication-envelope.js

@@ -1,37 +0,0 @@
-import { contentHash } from './canonical-json.js';
-import { validateEnvelopeSchema } from './publication-envelope-schema.js';
-
-export function createEnvelope({ id, spaceId, episode, facts }) {
-  const unsigned = {
-    id,
-    spaceId,
-    source: {
-      episodeId: episode.id,
-      kind: episode.sourceKind,
-      uri: episode.sourceUri,
-      capturedAt: episode.createdAt
-    },
-    facts: facts.map(projectFact),
-    policyVersion: '1'
-  };
-  return validateEnvelopeSchema({ ...unsigned, contentHash: contentHash(unsigned) });
-}
-
-export function verifyEnvelope(envelope) {
-  validateEnvelopeSchema(envelope);
-  const { contentHash: suppliedHash, ...unsigned } = envelope;
-  if (contentHash(unsigned) !== suppliedHash) {
-    throw new Error('Publication envelope content hash does not match');
-  }
-  return true;
-}
-
-function projectFact(fact) {
-  return {
-    id: fact.id,
-    subject: fact.subject,
-    predicate: fact.predicate,
-    object: fact.object,
-    sourceEpisodeId: fact.sourceEpisodeId
-  };
-}

package/src/publication/publication-policy.js

@@ -1,82 +0,0 @@
-import {
-  FactScope,
-  FactStatus,
-  Sensitivity,
-  SpaceKind,
-  isCurrentFact
-} from '../models.js';
-import { detectSensitiveContent } from '../security/sensitive-content.js';
-import { canonicalJson } from './canonical-json.js';
-
-export function validatePublication(store, { spaceId, episode, facts }) {
-  const space = store.getSpace(spaceId);
-  if (!space || space.kind !== SpaceKind.PUBLIC) {
-    throw new Error(`Publication target must be a public space: ${spaceId}`);
-  }
-  if (!episode?.id) throw new Error('Publication source episode is required');
-
-  const storedEpisode = store.getEpisode(episode.id);
-  if (!storedEpisode) throw new Error(`Publication source episode not found: ${episode.id}`);
-  if (storedEpisode.spaceId !== spaceId) throw new Error('Publication episode crosses spaces');
-  assertAuthentic('episode', episode, storedEpisode);
-  assertNoSensitiveSource(storedEpisode);
-
-  if (!Array.isArray(facts) || facts.length === 0) {
-    throw new TypeError('Publication facts must be a non-empty array');
-  }
-  const factIds = facts.map((fact) => fact?.id);
-  if (new Set(factIds).size !== factIds.length) {
-    throw new TypeError('Publication facts contain a duplicate fact id');
-  }
-  const storedFacts = facts.map((fact) => validateFact(store, fact, spaceId, storedEpisode.id));
-  return { episode: storedEpisode, facts: storedFacts };
-}
-
-function validateFact(store, fact, spaceId, episodeId) {
-  if (!fact?.id) throw new Error('Publication fact is required');
-  const stored = store.getFact(fact.id);
-  if (!stored) throw new Error(`Publication fact not found: ${fact.id}`);
-  assertAuthentic('fact', fact, stored);
-  if (stored.spaceId !== spaceId) throw new Error('Publication fact crosses spaces');
-  if (stored.sourceEpisodeId !== episodeId) throw new Error('Publication fact has missing source');
-  if (stored.scope !== FactScope.PUBLIC) throw new Error('Personal facts cannot be published');
-  if (stored.status !== FactStatus.CONFIRMED) throw new Error('Publication fact is not confirmed');
-  if (stored.sensitivity !== Sensitivity.NORMAL) {
-    throw new Error('Private or restricted facts cannot be published');
-  }
-  if (!isCurrentFact(stored) || !store.currentFacts(spaceId).some(({ id }) => id === stored.id)) {
-    throw new Error('Historical facts cannot be published');
-  }
-  assertSafeTexts([stored.subject, stored.predicate, stored.object]);
-  return stored;
-}
-
-function assertAuthentic(label, supplied, stored) {
-  if (canonicalJson(supplied) !== canonicalJson(stored)) {
-    throw new Error(`Publication ${label} does not match stored record`);
-  }
-}
-
-function assertNoSensitiveSource(episode) {
-  assertSafeTexts([
-    episode.body,
-    episode.sourceKind,
-    episode.sourceUri,
-    ...metadataStrings(episode.metadata)
-  ]);
-}
-
-function assertSafeTexts(texts) {
-  if (texts.some((text) => detectSensitiveContent(text).restricted)) {
-    throw new Error('Detected secret cannot be published');
-  }
-}
-
-function metadataStrings(value) {
-  if (typeof value === 'string') return [value];
-  if (Array.isArray(value)) return value.flatMap(metadataStrings);
-  if (value && typeof value === 'object') {
-    return Object.entries(value).flatMap(([key, item]) => [key, ...metadataStrings(item)]);
-  }
-  return [];
-}

package/src/publication/publication-service.js

@@ -1,48 +0,0 @@
-import { randomUUID } from 'node:crypto';
-
-import { createEnvelope, verifyEnvelope } from './publication-envelope.js';
-import { validatePublication } from './publication-policy.js';
-
-export class PublicationService {
-  constructor(store, { id = randomUUID } = {}) {
-    this.store = store;
-    this.id = id;
-  }
-
-  prepare(input) {
-    validatePublication(this.store, input);
-    return this.store.transaction(
-      () => this.#validateBuildAndEnqueue(input),
-      { mode: 'immediate' }
-    );
-  }
-
-  prepareInCurrentTransaction(input) {
-    return this.#validateBuildAndEnqueue(input);
-  }
-
-  verify(envelope) {
-    return verifyEnvelope(envelope);
-  }
-
-  #validateBuildAndEnqueue(input) {
-    const records = validatePublication(this.store, input);
-    return this.#enqueue({
-      spaceId: input.spaceId,
-      envelope: createEnvelope({
-        id: this.id(),
-        spaceId: input.spaceId,
-        ...records
-      })
-    });
-  }
-
-  #enqueue({ spaceId, envelope }) {
-    const outbox = this.store.enqueueOutbox({
-      kind: 'publication',
-      aggregateId: `${spaceId}:${envelope.id}`,
-      payload: { envelope }
-    });
-    return { envelope, outbox };
-  }
-}

package/src/router.js

@@ -1,58 +0,0 @@
-import { isCurrentFact } from './models.js';
-
-export class ContextRouter {
-  constructor(store) {
-    this.store = store;
-  }
-
-  searchContext({ personalSpaceId, query, includeHistorical = false }) {
-    const spaceIds = [
-      personalSpaceId,
-      ...this.store.subscriptionsFor(personalSpaceId).map((subscription) => subscription.spaceId)
-    ];
-    const facts = this.store.searchFacts(spaceIds, query, { includeHistorical });
-    const matches = facts.map((fact) => buildMatch(this.store, fact));
-
-    return {
-      query,
-      spaceIds,
-      matches,
-      facts,
-      answer: formatAnswer(facts)
-    };
-  }
-}
-
-function buildMatch(store, fact) {
-  const episode = store.getEpisode(fact.sourceEpisodeId);
-
-  return {
-    spaceId: fact.spaceId,
-    spaceName: store.getSpace(fact.spaceId)?.name ?? fact.spaceId,
-    current: isCurrentFact(fact),
-    fact,
-    source: episode
-      ? {
-          id: episode.id,
-          kind: episode.sourceKind,
-          uri: episode.sourceUri,
-          body: episode.body,
-          createdAt: episode.createdAt
-        }
-      : null
-  };
-}
-
-function formatAnswer(facts) {
-  if (facts.length === 0) {
-    return '没有找到相关当前事实';
-  }
-
-  return facts
-    .map((fact) => `${fact.subject}：${humanPredicate(fact.predicate)} 是 ${fact.object}`)
-    .join('\n');
-}
-
-function humanPredicate(predicate) {
-  return predicate.startsWith('has_') ? predicate.slice(4) : predicate;
-}

package/src/runtime-options.js

@@ -1,138 +0,0 @@
-import { existsSync as fileExistsSync } from 'node:fs';
-import { extname, resolve } from 'node:path';
-
-import { createApplication } from './app/create-application.js';
-import { SpaceKind } from './models.js';
-import { resolveSetupPaths } from './setup/paths.js';
-import { SqliteStore } from './storage/sqlite-store.js';
-
-const LEGACY_LOCAL_DB_PATH = '.fuli/context.db';
-const DEFAULT_PERSONAL_SPACE = '我';
-const RETRY_BUFFER = new Int32Array(new SharedArrayBuffer(4));
-const RETRY_DELAY_MS = 5;
-const STORE_OPEN_TIMEOUT_MS = 5000;
-
-export class RuntimeConfigurationError extends TypeError {}
-
-export function resolveRuntimeOptions(args = [], env = process.env, {
-  cwd = process.cwd(),
-  existsSync = fileExistsSync,
-  setupPaths = {}
-} = {}) {
-  const cliDbPath = runtimeValue(args, '--db');
-  const envDbPath = environmentValue(env, 'FULI_DB_PATH');
-  const systemDbPath = resolveSetupPaths({ env, ...setupPaths }).dbPath;
-  let defaultDbPath = systemDbPath;
-  if (cliDbPath === null && envDbPath === null) {
-    defaultDbPath = resolveDefaultDbPath({ cwd, existsSync, systemDbPath });
-    guardImplicitDefaultUpgrade({ cwd, existsSync });
-  }
-  return {
-    dbPath: cliDbPath ?? envDbPath ?? defaultDbPath,
-    personalSpaceName: runtimeValue(args, '--personal-space') ??
-      environmentValue(env, 'FULI_PERSONAL_SPACE') ?? DEFAULT_PERSONAL_SPACE
-  };
-}
-
-export function resolveStore({ dbPath }) {
-  if (extname(dbPath).toLowerCase() === '.json') {
-    throw new RuntimeConfigurationError(legacyJsonMessage(dbPath));
-  }
-  return openSqliteStore(dbPath);
-}
-
-export function quoteShellArgument(value, platform = process.platform) {
-  const argument = String(value);
-  if (platform === 'win32') {
-    if (argument.includes('"')) {
-      throw new TypeError('Windows paths cannot contain a double quote');
-    }
-    return `"${argument}"`;
-  }
-  return `'${argument.replaceAll("'", "'\\''")}'`;
-}
-
-function resolveDefaultDbPath({ cwd, existsSync, systemDbPath }) {
-  if (existsSync(systemDbPath)) return systemDbPath;
-  if (existsSync(resolve(cwd, LEGACY_LOCAL_DB_PATH))) return LEGACY_LOCAL_DB_PATH;
-  return systemDbPath;
-}
-
-function guardImplicitDefaultUpgrade({ cwd, existsSync }) {
-  const legacyPath = resolve(cwd, '.fuli/context.json');
-  const localDatabasePath = resolve(cwd, LEGACY_LOCAL_DB_PATH);
-  if (existsSync(legacyPath) && !existsSync(localDatabasePath)) {
-    throw new RuntimeConfigurationError(legacyJsonMessage(legacyPath));
-  }
-}
-
-function legacyJsonMessage(source) {
-  return `JSON is a retired legacy format (${quoteShellArgument(source)}). ` +
-    'The current Fuli CLI no longer provides SQLite knowledge commands or JSON migration.';
-}
-
-export function openLocalApplication({ dbPath, personalSpaceName = DEFAULT_PERSONAL_SPACE }) {
-  const store = resolveStore({ dbPath });
-  const app = createApplication({ store, activePersonalSpaceName: personalSpaceName });
-  try {
-    initializeLocalSpaces(app, store, personalSpaceName);
-    return app;
-  } catch (error) {
-    app.close();
-    throw error;
-  }
-}
-
-export function initializeLocalSpaces(app, store, personalSpaceName) {
-  return store.transaction(() => {
-    if (store.listSpaces().length === 0) {
-      if (personalSpaceName === DEFAULT_PERSONAL_SPACE) {
-        app.bootstrap();
-      } else {
-        const personal = app.createSpace(personalSpaceName, SpaceKind.PERSONAL);
-        const project = app.createSpace('工作', SpaceKind.PUBLIC);
-        app.subscribe(personal.id, project.id);
-      }
-    }
-    return app.requireActivePersonalSpace();
-  }, { mode: 'immediate' });
-}
-
-function runtimeValue(args, flag) {
-  const values = [];
-  for (let index = 0; index < args.length; index += 1) {
-    if (args[index] !== flag) continue;
-    const value = args[index + 1];
-    if (typeof value !== 'string' || !value.trim() || value.startsWith('--')) {
-      throw new TypeError(`Missing value for ${flag}`);
-    }
-    values.push(value);
-  }
-  if (values.length > 1) throw new TypeError(`Duplicate ${flag}`);
-  return values[0] ?? null;
-}
-
-function environmentValue(env, name) {
-  const value = env?.[name];
-  if (value === undefined) return null;
-  if (typeof value !== 'string' || !value.trim()) {
-    throw new TypeError(`${name} must not be empty`);
-  }
-  return value;
-}
-
-function openSqliteStore(dbPath) {
-  const deadline = Date.now() + STORE_OPEN_TIMEOUT_MS;
-  while (true) {
-    try {
-      return new SqliteStore(dbPath);
-    } catch (error) {
-      if (!isDatabaseBusy(error) || Date.now() >= deadline) throw error;
-      Atomics.wait(RETRY_BUFFER, 0, 0, RETRY_DELAY_MS);
-    }
-  }
-}
-
-function isDatabaseBusy(error) {
-  return error?.code === 'SQLITE_BUSY' || error?.code === 'SQLITE_LOCKED';
-}

package/src/security/episode-visibility.js

@@ -1,14 +0,0 @@
-import { detectSensitiveContent } from './sensitive-content.js';
-
-export function isRestrictedEpisode(episode) {
-  return [
-    episode.sourceKind,
-    episode.body,
-    episode.sourceUri,
-    JSON.stringify(episode.metadata)
-  ].some(hasSensitiveContent);
-}
-
-function hasSensitiveContent(text) {
-  return detectSensitiveContent(text).restricted;
-}

package/src/security/fact-visibility.js

@@ -1,15 +0,0 @@
-import { Sensitivity } from '../models.js';
-import { detectSensitiveContent } from './sensitive-content.js';
-
-export function isRestrictedFact(fact) {
-  return fact.sensitivity === Sensitivity.RESTRICTED ||
-    [
-      fact.subject,
-      fact.predicate,
-      fact.object
-    ].some(hasSensitiveContent);
-}
-
-function hasSensitiveContent(text) {
-  return detectSensitiveContent(text).restricted;
-}

package/src/security/source-metadata-policy.js

@@ -1,8 +0,0 @@
-import { ApplicationError, ApplicationErrorCode } from '../app/application-error.js';
-import { detectSensitiveContent } from './sensitive-content.js';
-
-export function assertSafeSourceMetadata(sourceKind, sourceUri, errorMessage) {
-  if ([sourceKind, sourceUri].some((text) => detectSensitiveContent(text).restricted)) {
-    throw new ApplicationError(ApplicationErrorCode.VALIDATION, errorMessage);
-  }
-}

package/src/storage/episode-evidence-preview.js

@@ -1,100 +0,0 @@
-export const MAX_EPISODE_EVIDENCE_BODY_BYTES = 16 * 1024;
-export const MAX_EPISODE_METADATA_BYTES = 16 * 1024;
-export const MAX_EPISODE_METADATA_FIELD_BYTES = 2048;
-export const DEFAULT_CORRECTION_EVIDENCE_PER_FACT = 5;
-export const MAX_CORRECTION_EVIDENCE_PER_FACT = 20;
-
-export function normalizeEvidencePreviewOptions(options = {}) {
-  const maxBodyBytes = options.maxBodyBytes ?? MAX_EPISODE_EVIDENCE_BODY_BYTES;
-  if (
-    !Number.isInteger(maxBodyBytes) ||
-    maxBodyBytes < 0 ||
-    maxBodyBytes > MAX_EPISODE_EVIDENCE_BODY_BYTES
-  ) {
-    throw new TypeError(
-      `Episode evidence body limit must be between 0 and ${MAX_EPISODE_EVIDENCE_BODY_BYTES}`
-    );
-  }
-  return {
-    maxBodyBytes,
-    includeRestricted: options.includeRestricted === true
-  };
-}
-
-export function normalizeCorrectionEvidencePreviewOptions(options = {}) {
-  const normalized = normalizeEvidencePreviewOptions(options);
-  const maxCorrectionsPerFact = options.maxCorrectionsPerFact ??
-    DEFAULT_CORRECTION_EVIDENCE_PER_FACT;
-  if (
-    !Number.isInteger(maxCorrectionsPerFact) ||
-    maxCorrectionsPerFact < 1 ||
-    maxCorrectionsPerFact > MAX_CORRECTION_EVIDENCE_PER_FACT
-  ) {
-    throw new TypeError(
-      `Correction evidence limit must be between 1 and ${MAX_CORRECTION_EVIDENCE_PER_FACT}`
-    );
-  }
-  return { ...normalized, maxCorrectionsPerFact };
-}
-
-export function previewEpisode(episode, options, { correction = false } = {}) {
-  if (!episode) return null;
-  const { value: body, truncated: bodyTruncated } = clipUtf8(
-    episode.body,
-    options.maxBodyBytes
-  );
-  const metadata = correction
-    ? previewCorrectionMetadata(episode.metadata)
-    : previewSourceMetadata(episode.metadata);
-  const truncatedFields = [];
-  if (bodyTruncated || episode.bodyTruncated) truncatedFields.push('body');
-  if (metadata.truncated || episode.metadataTruncated) truncatedFields.push('metadata');
-
-  return {
-    id: episode.id,
-    spaceId: episode.spaceId,
-    sourceKind: episode.sourceKind,
-    body,
-    sourceUri: episode.sourceUri,
-    metadata: metadata.value,
-    createdAt: episode.createdAt,
-    truncatedFields
-  };
-}
-
-export function clipUtf8(value, maxBytes) {
-  const text = typeof value === 'string' ? value : '';
-  const encoded = Buffer.from(text, 'utf8');
-  if (encoded.length <= maxBytes) return { value: text, truncated: false };
-  let end = maxBytes;
-  while (end > 0 && (encoded[end] & 0xc0) === 0x80) end -= 1;
-  return { value: encoded.subarray(0, end).toString('utf8'), truncated: true };
-}
-
-function previewSourceMetadata(metadata) {
-  if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
-    return { value: {}, truncated: metadata !== undefined };
-  }
-  const serialized = JSON.stringify(metadata);
-  if (Buffer.byteLength(serialized, 'utf8') > MAX_EPISODE_METADATA_BYTES) {
-    return { value: {}, truncated: true };
-  }
-  return { value: JSON.parse(serialized), truncated: false };
-}
-
-function previewCorrectionMetadata(metadata) {
-  const source = metadata && typeof metadata === 'object' && !Array.isArray(metadata)
-    ? metadata
-    : {};
-  const value = {};
-  let truncated = Object.keys(source).some(
-    (key) => !['kind', 'factId', 'action'].includes(key)
-  );
-  for (const key of ['kind', 'factId', 'action']) {
-    if (typeof source[key] !== 'string') continue;
-    const clipped = clipUtf8(source[key], MAX_EPISODE_METADATA_FIELD_BYTES);
-    value[key] = clipped.value;
-    truncated ||= clipped.truncated;
-  }
-  return { value, truncated };
-}

package/src/storage/fact-search-order.js

@@ -1,18 +0,0 @@
-export function compareSearchFacts(left, right) {
-  return compareText(right.validAt, left.validAt) || compareText(left.id, right.id);
-}
-
-export function searchTextSortKey(value) {
-  const text = String(value ?? '');
-  const key = Buffer.allocUnsafe(text.length * 2);
-  for (let index = 0; index < text.length; index += 1) {
-    key.writeUInt16BE(text.charCodeAt(index), index * 2);
-  }
-  return key;
-}
-
-function compareText(left, right) {
-  const first = String(left ?? '');
-  const second = String(right ?? '');
-  return first === second ? 0 : (first < second ? -1 : 1);
-}

package/src/storage/file/episode-evidence.js

@@ -1,37 +0,0 @@
-import { isRestrictedEpisode } from '../../security/episode-visibility.js';
-import {
-  normalizeCorrectionEvidencePreviewOptions,
-  normalizeEvidencePreviewOptions,
-  previewEpisode
-} from '../episode-evidence-preview.js';
-
-export function fileEpisodeEvidencePreview(index, spaceId, episodeId, options = {}) {
-  const normalized = normalizeEvidencePreviewOptions(options);
-  const episode = index.get(episodeId);
-  if (!isVisibleEpisode(episode, spaceId, normalized.includeRestricted)) return null;
-  return previewEpisode(episode, normalized);
-}
-
-export function fileCorrectionEpisodeEvidencePreviews(
-  index,
-  spaceId,
-  factIds,
-  options = {}
-) {
-  const normalized = normalizeCorrectionEvidencePreviewOptions(options);
-  return index.correctionWindows(spaceId, factIds, {
-    includeRestricted: normalized.includeRestricted,
-    limit: normalized.maxCorrectionsPerFact
-  }).map((group) => ({
-    factId: group.factId,
-    episodes: group.episodes.map(
-      (episode) => previewEpisode(episode, normalized, { correction: true })
-    ),
-    truncated: group.truncated
-  }));
-}
-
-function isVisibleEpisode(episode, spaceId, includeRestricted) {
-  return episode?.spaceId === spaceId &&
-    (includeRestricted || !isRestrictedEpisode(episode));
-}

package/src/storage/file/episode-index.js

@@ -1,59 +0,0 @@
-import { isRestrictedEpisode } from '../../security/episode-visibility.js';
-
-export class FileEpisodeIndex {
-  #byId = new Map();
-  #correctionsBySpace = new Map();
-  #safeCorrectionsBySpace = new Map();
-
-  constructor(episodes) {
-    this.rebuild(episodes);
-  }
-
-  rebuild(episodes) {
-    this.#byId = new Map();
-    this.#correctionsBySpace = new Map();
-    this.#safeCorrectionsBySpace = new Map();
-    for (const episode of episodes) this.add(episode);
-  }
-
-  add(episode) {
-    this.#byId.set(episode.id, episode);
-    const factId = episode.metadata?.kind === 'lens_correction'
-      ? episode.metadata.factId
-      : null;
-    if (typeof factId !== 'string') return;
-
-    addCorrection(this.#correctionsBySpace, episode, factId);
-    if (!isRestrictedEpisode(episode)) {
-      addCorrection(this.#safeCorrectionsBySpace, episode, factId);
-    }
-  }
-
-  get(id) {
-    return this.#byId.get(id) ?? null;
-  }
-
-  correctionWindows(spaceId, factIds, { includeRestricted, limit }) {
-    const index = includeRestricted
-      ? this.#correctionsBySpace
-      : this.#safeCorrectionsBySpace;
-    const byFact = index.get(spaceId) ?? new Map();
-    return [...new Set(factIds)].map((factId) => {
-      const episodes = byFact.get(factId) ?? [];
-      return {
-        factId,
-        episodes: episodes.slice(Math.max(0, episodes.length - limit)).reverse(),
-        truncated: episodes.length > limit
-      };
-    });
-  }
-}
-
-function addCorrection(index, episode, factId) {
-  const byFact = index.get(episode.spaceId) ?? new Map();
-  const episodes = byFact.get(factId) ?? [];
-  episodes.push(episode);
-  episodes.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
-  byFact.set(factId, episodes);
-  index.set(episode.spaceId, byFact);
-}

package/src/storage/file/fact-search.js

@@ -1,60 +0,0 @@
-import { isCurrentFact } from '../../models.js';
-import { isRestrictedEpisode } from '../../security/episode-visibility.js';
-import { isRestrictedFact } from '../../security/fact-visibility.js';
-import { compareSearchFacts } from '../fact-search-order.js';
-
-export function searchFileFacts(facts, episodeIndex, spaceIds, query, options = {}) {
-  return searchFileFactsPage(facts, episodeIndex, spaceIds, query, options).facts;
-}
-
-export function searchFileFactsPage(facts, episodeIndex, spaceIds, query, options = {}) {
-  const search = {
-    includeHistorical: options.includeHistorical ?? false,
-    scope: options.scope ?? null,
-    limit: options.limit ?? null,
-    excludeRestricted: options.excludeRestricted === true,
-    safeSourceSpaceId: options.safeSourceSpaceId ?? null,
-    maxObjectBytes: options.maxObjectBytes ?? null,
-    query: query.toLowerCase()
-  };
-
-  if (search.limit !== null && (!Number.isInteger(search.limit) || search.limit <= 0)) {
-    throw new TypeError('Fact search limit must be a positive integer');
-  }
-
-  const selected = [];
-  let objectLimitTruncated = false;
-  for (const fact of facts) {
-    if (!matchesSearchWithoutObjectLimit(fact, episodeIndex, spaceIds, search)) continue;
-    if (
-      search.maxObjectBytes !== null &&
-      Buffer.byteLength(fact.object, 'utf8') > search.maxObjectBytes
-    ) {
-      objectLimitTruncated = true;
-      continue;
-    }
-    selected.push(fact);
-    if (search.limit === null) continue;
-    selected.sort(compareSearchFacts);
-    if (selected.length > search.limit) selected.pop();
-  }
-  return { facts: selected, objectLimitTruncated };
-}
-
-function matchesSearchWithoutObjectLimit(fact, episodeIndex, spaceIds, search) {
-  if (!spaceIds.includes(fact.spaceId)) return false;
-  if (search.scope !== null && fact.scope !== search.scope) return false;
-  if (!search.includeHistorical && !isCurrentFact(fact)) return false;
-  if (search.excludeRestricted && isRestrictedFact(fact)) return false;
-  if (search.safeSourceSpaceId !== null) {
-    const source = episodeIndex.get(fact.sourceEpisodeId);
-    if (
-      !source ||
-      source.spaceId !== search.safeSourceSpaceId ||
-      isRestrictedEpisode(source)
-    ) return false;
-  }
-  return `${fact.subject} ${fact.predicate} ${fact.object}`
-    .toLowerCase()
-    .includes(search.query);
-}