fuli-context 0.4.0 → 0.7.2

package/src/lens/lens-resource-service.js

@@ -1,103 +0,0 @@
-import { SpaceKind } from '../models.js';
-import {
-  isSafeResourceFact,
-  isSafeResourceText,
-  projectCurrentFact,
-  projectHistoryItem,
-  projectSubscription
-} from './lens-resource-projection.js';
-import { selectCurrentFacts, selectHistoryItems } from './lens-resource-selection.js';
-
-export const CURRENT_LENS_BUDGET_BYTES = 16 * 1024;
-export const HISTORY_BUDGET_BYTES = 64 * 1024;
-export const HISTORY_LIMIT = 100;
-
-export class LensResourceService {
-  constructor({ store, lens, activePersonalSpace }) {
-    this.store = store;
-    this.lens = lens;
-    this.activePersonalSpace = activePersonalSpace;
-  }
-
-  current() {
-    const personal = this.activePersonalSpace();
-    const result = this.lens.getUserLens({
-      personalSpaceId: personal.id,
-      task: '',
-      budget: CURRENT_LENS_BUDGET_BYTES,
-      includeObserved: true,
-      includeSuggested: false,
-      includeRestricted: false
-    });
-    const projected = result.facts.map(projectCurrentFact).filter(Boolean);
-    const selected = selectCurrentFacts(projected, CURRENT_LENS_BUDGET_BYTES);
-    return safePayload({
-      personalSpaceId: personal.id,
-      facts: selected.facts,
-      text: selected.text,
-      truncated: result.truncated ||
-        projected.length < result.facts.length ||
-        selected.truncated,
-      budget: {
-        encoding: 'utf-8',
-        limitBytes: CURRENT_LENS_BUDGET_BYTES,
-        usedBytes: Buffer.byteLength(selected.text, 'utf8')
-      }
-    });
-  }
-
-  history() {
-    const personal = this.activePersonalSpace();
-    const result = this.lens.searchUserContext({
-      personalSpaceId: personal.id,
-      query: '',
-      includeHistorical: true,
-      includeRestricted: false,
-      maxFactObjectBytes: HISTORY_BUDGET_BYTES,
-      maxEvidenceBodyBytes: 0,
-      scanLimit: HISTORY_LIMIT * 2,
-      factFilter: isSafeResourceFact,
-      limit: HISTORY_LIMIT
-    });
-    const safeItems = result.facts.map(projectHistoryItem).filter(Boolean);
-    const selected = selectHistoryItems(safeItems, {
-      limit: HISTORY_LIMIT,
-      budgetBytes: HISTORY_BUDGET_BYTES
-    });
-    return safePayload({
-      personalSpaceId: personal.id,
-      limit: HISTORY_LIMIT,
-      count: selected.items.length,
-      truncated: result.truncated ||
-        safeItems.length < result.facts.length ||
-        selected.truncated,
-      budget: {
-        encoding: 'utf-8',
-        limitBytes: HISTORY_BUDGET_BYTES,
-        itemsBytes: selected.itemsBytes
-      },
-      items: selected.items
-    }, HISTORY_BUDGET_BYTES);
-  }
-
-  subscribed() {
-    const personal = this.activePersonalSpace();
-    const subscriptions = this.store.subscriptionsFor(personal.id)
-      .map((subscription) => ({ subscription, space: this.store.getSpace(subscription.spaceId) }))
-      .filter(({ space }) => space?.kind === SpaceKind.PUBLIC)
-      .map(({ subscription, space }) => projectSubscription(subscription, space))
-      .filter(Boolean);
-    return safePayload({ personalSpaceId: personal.id, subscriptions });
-  }
-}
-
-function safePayload(payload, limitBytes = null) {
-  const serialized = JSON.stringify(payload);
-  if (!isSafeResourceText(serialized)) {
-    throw new Error('Unsafe resource projection');
-  }
-  if (limitBytes && Buffer.byteLength(serialized, 'utf8') > limitBytes) {
-    throw new Error('Resource projection exceeds its byte budget');
-  }
-  return payload;
-}

package/src/lens/lens-search-query.js

@@ -1,122 +0,0 @@
-import { ApplicationError, ApplicationErrorCode } from '../app/application-error.js';
-import { FactScope } from '../models.js';
-import { MAX_EPISODE_EVIDENCE_BODY_BYTES } from '../storage/episode-evidence-preview.js';
-import { assertStorePort } from '../storage/store-port.js';
-import { requirePersonalSpace } from './lens-input.js';
-import {
-  buildCorrectionIndex,
-  isSearchableFact,
-  projectSearchFact
-} from './lens-query-projection.js';
-
-export const DEFAULT_SEARCH_USER_CONTEXT_LIMIT = 20;
-export const MAX_SEARCH_USER_CONTEXT_LIMIT = 100;
-const MAX_SEARCH_USER_CONTEXT_SCAN_LIMIT = 200;
-
-export class LensSearchQuery {
-  constructor(store) {
-    assertStorePort(store);
-    this.store = store;
-  }
-
-  searchUserContext({
-    personalSpaceId,
-    query,
-    includeHistorical = false,
-    includeRestricted = false,
-    requireSafeSource = false,
-    maxFactObjectBytes = null,
-    maxEvidenceBodyBytes = MAX_EPISODE_EVIDENCE_BODY_BYTES,
-    limit = DEFAULT_SEARCH_USER_CONTEXT_LIMIT,
-    scanLimit = limit,
-    factFilter = null
-  }) {
-    requirePersonalSpace(this.store, personalSpaceId);
-    validateQuery(query);
-    validateSearchLimit(limit);
-    validateScanOptions(scanLimit, limit, factFilter);
-
-    const allowRestricted = includeRestricted === true;
-    const page = this.store.searchFactsPage([personalSpaceId], query, {
-      includeHistorical,
-      scope: FactScope.PERSONAL,
-      excludeRestricted: !allowRestricted,
-      safeSourceSpaceId: requireSafeSource === true ? personalSpaceId : null,
-      maxObjectBytes: maxFactObjectBytes,
-      limit: scanLimit + 1
-    });
-    const candidates = page.facts;
-    const scanned = candidates.slice(0, scanLimit);
-    const facts = scanned
-      .filter((fact) => fact.spaceId === personalSpaceId && fact.scope === FactScope.PERSONAL)
-      .filter((fact) => isSearchableFact(fact, {
-        includeHistorical,
-        includeRestricted: allowRestricted
-      }))
-      .filter((fact) => factFilter?.(fact) ?? true);
-    const selected = facts.slice(0, limit);
-    const correctionIndex = buildCorrectionIndex(
-      this.store.correctionEpisodeEvidencePreviews(
-        personalSpaceId,
-        selected.map((fact) => fact.id),
-        { includeRestricted: allowRestricted, maxBodyBytes: maxEvidenceBodyBytes }
-      ),
-      personalSpaceId,
-      allowRestricted
-    );
-    return {
-      personalSpaceId,
-      query,
-      truncated: page.objectLimitTruncated ||
-        candidates.length > scanLimit ||
-        facts.length > limit ||
-        facts.length < scanned.length,
-      facts: selected.map((fact) => {
-        const source = this.store.episodeEvidencePreview(
-          personalSpaceId,
-          fact.sourceEpisodeId,
-          { includeRestricted: allowRestricted, maxBodyBytes: maxEvidenceBodyBytes }
-        );
-        return projectSearchFact(
-          this.store,
-          fact,
-          source,
-          personalSpaceId,
-          correctionIndex,
-          allowRestricted
-        );
-      })
-    };
-  }
-}
-
-function validateScanOptions(scanLimit, limit, factFilter) {
-  if (
-    !Number.isInteger(scanLimit) ||
-    scanLimit < limit ||
-    scanLimit > MAX_SEARCH_USER_CONTEXT_SCAN_LIMIT
-  ) {
-    throw new ApplicationError(
-      ApplicationErrorCode.VALIDATION,
-      `Scan limit must be an integer between the result limit and ${MAX_SEARCH_USER_CONTEXT_SCAN_LIMIT}`
-    );
-  }
-  if (factFilter !== null && typeof factFilter !== 'function') {
-    throw new ApplicationError(ApplicationErrorCode.VALIDATION, 'Fact filter must be a function');
-  }
-}
-
-function validateQuery(query) {
-  if (typeof query !== 'string') {
-    throw new ApplicationError(ApplicationErrorCode.VALIDATION, 'Query must be a string');
-  }
-}
-
-function validateSearchLimit(limit) {
-  if (!Number.isInteger(limit) || limit < 1 || limit > MAX_SEARCH_USER_CONTEXT_LIMIT) {
-    throw new ApplicationError(
-      ApplicationErrorCode.VALIDATION,
-      `Limit must be an integer between 1 and ${MAX_SEARCH_USER_CONTEXT_LIMIT}`
-    );
-  }
-}

package/src/lens/lens-service.js

@@ -1,183 +0,0 @@
-import { ApplicationError, ApplicationErrorCode } from '../app/application-error.js';
-import { FactScope, FactStatus, Sensitivity } from '../models.js';
-import { assertSafeSourceMetadata } from '../security/source-metadata-policy.js';
-import { assertStorePort } from '../storage/store-port.js';
-import { writePersonalFact, writePersonalFactSpecs } from './lens-fact-writer.js';
-import { assertSafeLensTexts, requirePersonalSpace, validateLensWriteInput } from './lens-input.js';
-import { LensCorrectionService } from './lens-correction-service.js';
-const OBSERVATION_INFERENCES = new Set(['direct', 'inferred']);
-const IMMEDIATE = { mode: 'immediate' };
-const SOURCE_METADATA_ERROR = 'Sensitive source metadata is not allowed in Personal Lens';
-
-export class LensService {
-  #corrections;
-
-  constructor(store) {
-    assertStorePort(store);
-    this.store = store;
-    this.#corrections = new LensCorrectionService(store);
-  }
-  rememberUserFact({
-    personalSpaceId,
-    subject = 'user',
-    predicate,
-    value,
-    sourceText,
-    sourceKind = 'conversation',
-    sensitivity = Sensitivity.NORMAL,
-    confidence = 1
-  }) {
-    assertSafeSourceMetadata(sourceKind, null, SOURCE_METADATA_ERROR);
-    this.#validate(personalSpaceId, [subject, predicate, value, sourceText], sensitivity, confidence);
-    return this.store.transaction(() => {
-      const episode = this.store.addEpisode(personalSpaceId, sourceKind, sourceText);
-      const fact = this.#writeFact({
-        personalSpaceId, subject, predicate, value, episode,
-        status: FactStatus.CONFIRMED, sensitivity, confidence
-      });
-      return { episode, fact };
-    }, IMMEDIATE);
-  }
-  rememberUserFactsFromSourceInCurrentTransaction({
-    personalSpaceId,
-    subject = 'user',
-    specs,
-    sourceText,
-    sourceKind,
-    sourceUri = null,
-    sensitivity = Sensitivity.NORMAL,
-    confidence = 1
-  }) {
-    assertSafeSourceMetadata(sourceKind, sourceUri, SOURCE_METADATA_ERROR);
-    const specTexts = specs.flatMap(specTextsForValidation);
-    this.#validate(
-      personalSpaceId,
-      [subject, sourceText, ...specTexts],
-      sensitivity,
-      confidence
-    );
-    const episode = this.store.addEpisode(personalSpaceId, sourceKind, sourceText, sourceUri);
-    const facts = writePersonalFactSpecs(this.store, {
-      spaceId: personalSpaceId,
-      subject,
-      specs,
-      sourceEpisodeId: episode.id,
-      sensitivity,
-      confidence
-    });
-    return { episode, facts };
-  }
-  writeUserFactsForEpisodeInCurrentTransaction({
-    personalSpaceId,
-    subject = 'user',
-    specs,
-    episode,
-    sensitivity = Sensitivity.NORMAL,
-    confidence = 1
-  }) {
-    assertSafeSourceMetadata(episode?.sourceKind, episode?.sourceUri, SOURCE_METADATA_ERROR);
-    if (episode.spaceId !== personalSpaceId) {
-      throw new ApplicationError(ApplicationErrorCode.VALIDATION, 'Lens source episode belongs to another space');
-    }
-    this.#validate(
-      personalSpaceId,
-      [subject, episode.body, ...specs.flatMap(specTextsForValidation)],
-      sensitivity,
-      confidence
-    );
-    const facts = writePersonalFactSpecs(this.store, {
-      spaceId: personalSpaceId,
-      subject,
-      specs,
-      sourceEpisodeId: episode.id,
-      sensitivity,
-      confidence
-    });
-    return { episode, facts };
-  }
-  submitUserObservation({
-    personalSpaceId,
-    subject = 'user',
-    predicate,
-    value,
-    evidenceText,
-    inference,
-    sourceKind = 'observation',
-    sensitivity = Sensitivity.NORMAL,
-    confidence = inference === 'inferred' ? 0.5 : 1
-  }) {
-    assertSafeSourceMetadata(sourceKind, null, SOURCE_METADATA_ERROR);
-    this.#validate(personalSpaceId, [subject, predicate, value, evidenceText], sensitivity, confidence);
-    if (!OBSERVATION_INFERENCES.has(inference)) {
-      throw new ApplicationError(
-        ApplicationErrorCode.VALIDATION,
-        'Observation inference must be direct or inferred'
-      );
-    }
-    return this.store.transaction(() => {
-      const episode = this.store.addEpisode(personalSpaceId, sourceKind, evidenceText);
-      const fact = this.#writeFact({
-        personalSpaceId, subject, predicate, value, episode,
-        status: inference === 'inferred' ? FactStatus.SUGGESTED : FactStatus.OBSERVED,
-        sensitivity, confidence
-      });
-      return { episode, fact };
-    }, IMMEDIATE);
-  }
-  confirmObservation({ personalSpaceId, factId, sourceText, sourceKind = 'confirmation' }) {
-    assertSafeSourceMetadata(sourceKind, null, SOURCE_METADATA_ERROR);
-    requirePersonalSpace(this.store, personalSpaceId);
-    assertSafeLensTexts([sourceText]);
-    return this.store.transaction(() => {
-      const original = this.#findConfirmableFact(personalSpaceId, factId);
-      assertSafeLensTexts([original.subject, original.predicate, original.object]);
-      const episode = this.store.addEpisode(personalSpaceId, sourceKind, sourceText);
-      const fact = this.#writeFact({
-        personalSpaceId,
-        subject: original.subject,
-        predicate: original.predicate,
-        value: original.object,
-        episode,
-        status: FactStatus.CONFIRMED,
-        sensitivity: original.sensitivity,
-        confidence: original.confidence
-      });
-      return { episode, fact, replacedFact: original };
-    }, IMMEDIATE);
-  }
-  correctUserFact(input) {
-    assertSafeSourceMetadata(input.sourceKind, null, SOURCE_METADATA_ERROR);
-    return this.#corrections.correctUserFact(input);
-  }
-
-  #writeFact(input) {
-    return writePersonalFact(this.store, {
-      spaceId: input.personalSpaceId,
-      subject: input.subject,
-      predicate: input.predicate,
-      object: input.value,
-      sourceEpisodeId: input.episode.id,
-      status: input.status,
-      sensitivity: input.sensitivity,
-      confidence: input.confidence
-    });
-  }
-  #validate(personalSpaceId, texts, sensitivity, confidence) {
-    validateLensWriteInput(this.store, { personalSpaceId, texts, sensitivity, confidence });
-  }
-
-  #findConfirmableFact(personalSpaceId, factId) {
-    const fact = this.store.getFact(factId);
-    if (!fact || fact.spaceId !== personalSpaceId || fact.scope !== FactScope.PERSONAL) {
-      throw new ApplicationError(ApplicationErrorCode.NOT_FOUND, `Observation not found: ${factId}`);
-    }
-    if (fact.invalidAt || ![FactStatus.OBSERVED, FactStatus.SUGGESTED].includes(fact.status)) {
-      throw new ApplicationError(ApplicationErrorCode.VALIDATION, `Observation cannot be confirmed: ${factId}`);
-    }
-    return fact;
-  }
-}
-function specTextsForValidation(spec) {
-  return [spec.subject, spec.predicate, spec.object, spec.oldValue, spec.newValue]
-    .filter(value => value !== undefined);
-}

package/src/models.js

@@ -1,44 +0,0 @@
-export const SpaceKind = Object.freeze({
-  PERSONAL: 'personal',
-  PUBLIC: 'public'
-});
-
-export const CandidateStatus = Object.freeze({
-  PENDING: 'pending',
-  SYNCED: 'synced',
-  PERSONAL_ONLY: 'personal_only',
-  IGNORED: 'ignored'
-});
-
-export const FactStatus = Object.freeze({
-  CONFIRMED: 'confirmed',
-  OBSERVED: 'observed',
-  SUGGESTED: 'suggested',
-  REJECTED: 'rejected',
-  DEPRECATED: 'deprecated'
-});
-
-export const Sensitivity = Object.freeze({
-  NORMAL: 'normal',
-  PRIVATE: 'private',
-  RESTRICTED: 'restricted'
-});
-
-export const FactScope = Object.freeze({
-  PERSONAL: 'personal',
-  PUBLIC: 'public'
-});
-
-export const PublishRoute = Object.freeze({
-  PERSONAL: 'personal',
-  PUBLIC: 'public',
-  CANDIDATE: 'candidate'
-});
-
-export function nowIso() {
-  return new Date().toISOString();
-}
-
-export function isCurrentFact(fact) {
-  return !fact.invalidAt && ![FactStatus.REJECTED, FactStatus.DEPRECATED].includes(fact.status);
-}

package/src/observer.js

@@ -1,83 +0,0 @@
-import { execFileSync } from 'node:child_process';
-
-import { IngestionService } from './ingestion.js';
-
-const CONTEXT_MARKERS = ['可能', '也许', '不确定', '待确认', '以后要', '似乎'];
-const URL_PATTERN = /https?:\/\//;
-const KEY_VALUE_PATTERN = /^[\p{L}\p{N}_.-]+\s*[:：]\s*\S/u;
-const FORBIDDEN_RULE_PATTERN =
-  /^(?:这个项目|本项目|项目)?\s*(?:禁止|不要|不允许)\s*(?:使用|采用|引入|用)?\s*\S+/;
-
-export function observeGitDiff({ store, personalSpaceId, targetSpaceId = null, cwd = process.cwd() }) {
-  const service = new IngestionService(store);
-  const resolvedTargetSpaceId = targetSpaceId ?? inferOnlySubscribedSpace(store, personalSpaceId);
-  const observed = collectGitDiffEpisodes({ cwd }).map((episode) => ({
-    ...episode,
-    result: service.remember({
-      personalSpaceId,
-      targetSpaceId: resolvedTargetSpaceId,
-      sourceKind: 'git',
-      body: episode.body,
-      sourceUri: episode.sourceUri
-    })
-  }));
-
-  return { observed };
-}
-
-function inferOnlySubscribedSpace(store, personalSpaceId) {
-  const subscriptions = store.subscriptionsFor(personalSpaceId);
-  return subscriptions.length === 1 ? subscriptions[0].spaceId : null;
-}
-
-export function collectGitDiffEpisodes({ cwd = process.cwd(), maxBuffer = 1024 * 1024 } = {}) {
-  const diff = execFileSync('git', ['diff', '--unified=0', '--no-ext-diff'], {
-    cwd,
-    encoding: 'utf8',
-    maxBuffer
-  });
-  return parseGitDiff(diff);
-}
-
-export function parseGitDiff(diff) {
-  const episodes = [];
-  let currentPath = null;
-
-  for (const rawLine of diff.split(/\r?\n/)) {
-    if (rawLine.startsWith('+++ b/')) {
-      currentPath = rawLine.slice('+++ b/'.length);
-      continue;
-    }
-
-    if (rawLine.startsWith('+++ ')) {
-      currentPath = null;
-      continue;
-    }
-
-    if (!rawLine.startsWith('+')) continue;
-
-    const body = rawLine.slice(1).trim();
-    if (!body) continue;
-    if (!isContextWorthyLine(body)) continue;
-
-    episodes.push({
-      body,
-      sourceUri: `git-diff:${currentPath ?? 'unknown'}`
-    });
-  }
-
-  return episodes;
-}
-
-function isContextWorthyLine(body) {
-  return (
-    KEY_VALUE_PATTERN.test(body) ||
-    URL_PATTERN.test(body) ||
-    body.startsWith('替代:') ||
-    body.startsWith('替代：') ||
-    body.startsWith('禁止:') ||
-    body.startsWith('禁止：') ||
-    FORBIDDEN_RULE_PATTERN.test(body) ||
-    CONTEXT_MARKERS.some((marker) => body.includes(marker))
-  );
-}

package/src/project-rules.js

@@ -1,33 +0,0 @@
-export function getProjectRules(store, spaceId) {
-  const facts = store.currentFacts(spaceId).map((fact) => enrichFact(store, fact));
-
-  return {
-    spaceId,
-    spaceName: store.getSpace(spaceId)?.name ?? spaceId,
-    forbidden: facts.filter((fact) => fact.predicate === 'forbids'),
-    parameters: facts.filter(isProjectParameter),
-    links: facts.filter((fact) => fact.predicate === 'has_url'),
-    facts
-  };
-}
-
-function enrichFact(store, fact) {
-  const episode = store.getEpisode(fact.sourceEpisodeId);
-
-  return {
-    ...fact,
-    source: episode
-      ? {
-          id: episode.id,
-          kind: episode.sourceKind,
-          uri: episode.sourceUri,
-          body: episode.body,
-          createdAt: episode.createdAt
-        }
-      : null
-  };
-}
-
-function isProjectParameter(fact) {
-  return fact.predicate.startsWith('has_') && fact.predicate !== 'has_url';
-}

package/src/publication/outbox-service.js

@@ -1,46 +0,0 @@
-const MAX_LOOKAHEAD = '9999-12-31T23:59:59.999Z';
-const SAFE_FAILURE = 'Publication delivery failed';
-
-export class OutboxService {
-  constructor(store, { now = () => new Date() } = {}) {
-    this.store = store;
-    this.now = now;
-  }
-
-  pending(at = this.now()) {
-    return this.store.listPendingOutbox(toIso(at));
-  }
-
-  markSent(id) {
-    return this.store.transaction(() => {
-      this.#requirePending(id);
-      return this.store.markOutboxSent(id, toIso(this.now()));
-    }, { mode: 'immediate' });
-  }
-
-  markFailed(id, _error) {
-    return this.store.transaction(() => {
-      const row = this.#requirePending(id);
-      const now = new Date(this.now());
-      const delayMinutes = retryDelayMinutes(row.attempts + 1);
-      const nextAttemptAt = new Date(now.getTime() + delayMinutes * 60_000).toISOString();
-      return this.store.markOutboxFailed(id, SAFE_FAILURE, nextAttemptAt);
-    }, { mode: 'immediate' });
-  }
-
-  #requirePending(id) {
-    const row = this.store.listPendingOutbox(MAX_LOOKAHEAD).find((item) => item.id === id);
-    if (!row) throw new Error(`Pending Outbox row not found: ${id}`);
-    return row;
-  }
-}
-
-export function retryDelayMinutes(attempt) {
-  return Math.min(30, 2 ** Math.max(0, attempt - 1));
-}
-
-function toIso(value) {
-  const date = value instanceof Date ? value : new Date(value);
-  if (Number.isNaN(date.getTime())) throw new TypeError('Outbox time must be valid');
-  return date.toISOString();
-}

package/src/publication/publication-envelope-schema.js

@@ -1,75 +0,0 @@
-const ENVELOPE_KEYS = ['contentHash', 'facts', 'id', 'policyVersion', 'source', 'spaceId'];
-const SOURCE_KEYS = ['capturedAt', 'episodeId', 'kind', 'uri'];
-const FACT_KEYS = ['id', 'object', 'predicate', 'sourceEpisodeId', 'subject'];
-
-export function validateEnvelopeSchema(envelope) {
-  assertExactObject('Publication envelope', envelope, ENVELOPE_KEYS);
-  assertNonEmptyString('Publication envelope id', envelope.id);
-  assertNonEmptyString('Publication envelope spaceId', envelope.spaceId);
-  if (envelope.policyVersion !== '1') {
-    throw new TypeError('Publication envelope policyVersion must be 1');
-  }
-  if (!/^[a-f0-9]{64}$/.test(envelope.contentHash)) {
-    throw new TypeError('Publication envelope contentHash must be lowercase SHA-256');
-  }
-
-  validateSource(envelope.source);
-  validateFacts(envelope.facts, envelope.source.episodeId);
-  return envelope;
-}
-
-function validateSource(source) {
-  assertExactObject('Publication source', source, SOURCE_KEYS);
-  assertNonEmptyString('Publication source episodeId', source.episodeId);
-  assertNonEmptyString('Publication source kind', source.kind);
-  if (source.uri !== null && typeof source.uri !== 'string') {
-    throw new TypeError('Publication source uri must be a string or null');
-  }
-  assertNonEmptyString('Publication source capturedAt', source.capturedAt);
-  const capturedAt = new Date(source.capturedAt);
-  if (Number.isNaN(capturedAt.getTime()) || capturedAt.toISOString() !== source.capturedAt) {
-    throw new TypeError('Publication source capturedAt must be an ISO timestamp');
-  }
-}
-
-function validateFacts(facts, episodeId) {
-  if (!Array.isArray(facts) || facts.length === 0) {
-    throw new TypeError('Publication envelope facts must be a non-empty array');
-  }
-  const ids = new Set();
-  for (const fact of facts) {
-    assertExactObject('Publication fact', fact, FACT_KEYS);
-    assertNonEmptyString('Publication fact id', fact.id);
-    assertNonEmptyString('Publication fact subject', fact.subject);
-    assertNonEmptyString('Publication fact predicate', fact.predicate);
-    if (typeof fact.object !== 'string') {
-      throw new TypeError('Publication fact object must be a string');
-    }
-    assertNonEmptyString('Publication fact sourceEpisodeId', fact.sourceEpisodeId);
-    if (fact.sourceEpisodeId !== episodeId) {
-      throw new TypeError('Publication fact sourceEpisodeId must match the source episode');
-    }
-    if (ids.has(fact.id)) throw new TypeError(`Duplicate publication fact id: ${fact.id}`);
-    ids.add(fact.id);
-  }
-}
-
-function assertExactObject(label, value, expectedKeys) {
-  if (!isPlainObject(value)) throw new TypeError(`${label} must be a plain object`);
-  const keys = Object.keys(value).sort();
-  if (keys.length !== expectedKeys.length || keys.some((key, index) => key !== expectedKeys[index])) {
-    throw new TypeError(`${label} has invalid schema keys`);
-  }
-}
-
-function assertNonEmptyString(label, value) {
-  if (typeof value !== 'string' || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string`);
-  }
-}
-
-function isPlainObject(value) {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}