fuli-context 0.2.0

package/src/mcp/tool-result.js

@@ -0,0 +1,167 @@
+import { ApplicationError } from '../app/application-error.js';
+
+const OMITTED_KEYS = new Set([
+  'store',
+  'dbpath',
+  'databasepath',
+  'snapshot',
+  'fullsnapshot'
+]);
+const RESULT_LIMIT_BYTES = 1200;
+const RESULT_STRING_LIMIT_BYTES = 512;
+const RESULT_ITEM_LIMIT = 20;
+const RESULT_PROPERTY_LIMIT = 64;
+const RESULT_DEPTH_LIMIT = 8;
+const MESSAGE_LIMIT = 240;
+const TRUNCATION_MARKER = '...[truncated]';
+
+export function successToolResult(value, { limitBytes = RESULT_LIMIT_BYTES } = {}) {
+  const state = { truncated: false };
+  const sanitized = sanitize(value, state);
+  const candidate = isObject(sanitized) && !Array.isArray(sanitized)
+    ? sanitized
+    : { result: sanitized };
+  const structuredContent = boundedStructuredContent(
+    candidate,
+    state.truncated,
+    limitBytes
+  );
+  return {
+    content: [{ type: 'text', text: JSON.stringify(structuredContent) }],
+    structuredContent
+  };
+}
+
+export function errorToolResult(error) {
+  const controlled = error instanceof ApplicationError;
+  const code = controlled ? error.code : 'internal_error';
+  const message = controlled
+    ? applicationErrorMessage(error)
+    : 'Tool execution failed';
+  const structuredContent = { error: { code, message } };
+  return {
+    content: [{ type: 'text', text: `${code}: ${message}` }],
+    structuredContent,
+    isError: true
+  };
+}
+
+export function applicationErrorMessage(error) {
+  const stableMessage = String(error.message).split(':', 1)[0];
+  return boundedMessage(stableMessage);
+}
+
+export function protocolErrorResult(message) {
+  if (message.includes('Input validation error')) {
+    return errorToolResult(new ApplicationError('validation', 'Invalid tool arguments'));
+  }
+  return errorToolResult(new Error('Protocol tool failure'));
+}
+
+function sanitize(value, state, seen = new WeakSet(), depth = 0) {
+  if (!isObject(value)) return value;
+  if (seen.has(value)) return '[circular]';
+  if (depth >= RESULT_DEPTH_LIMIT) {
+    state.truncated = true;
+    return TRUNCATION_MARKER;
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    if (value.length > RESULT_ITEM_LIMIT) state.truncated = true;
+    return value.slice(0, RESULT_ITEM_LIMIT)
+      .map((item) => sanitize(item, state, seen, depth + 1));
+  }
+
+  const sanitized = {};
+  let included = 0;
+  for (const [key, item] of Object.entries(value)) {
+    if (OMITTED_KEYS.has(key.toLowerCase().replaceAll('_', ''))) continue;
+    if (included >= RESULT_PROPERTY_LIMIT) {
+      state.truncated = true;
+      break;
+    }
+    sanitized[key] = sanitize(item, state, seen, depth + 1);
+    included += 1;
+  }
+  return sanitized;
+}
+
+function boundedStructuredContent(value, alreadyTruncated, limitBytes) {
+  const budget = Number.isInteger(limitBytes) && limitBytes > 0
+    ? limitBytes
+    : RESULT_LIMIT_BYTES;
+  if (!alreadyTruncated && jsonBytes(value) <= budget) return value;
+  return projectObject(value, budget, 0, true);
+}
+
+function projectValue(value, budget, depth) {
+  if (budget < 2) return undefined;
+  if (typeof value === 'string') return projectString(value, budget);
+  if (!isObject(value)) return jsonBytes(value) <= budget ? value : undefined;
+  if (depth >= RESULT_DEPTH_LIMIT) return projectString(TRUNCATION_MARKER, budget);
+  if (Array.isArray(value)) return projectArray(value, budget, depth);
+  return projectObject(value, budget, depth);
+}
+
+function projectString(value, budget) {
+  const limit = Math.min(budget, RESULT_STRING_LIMIT_BYTES);
+  if (jsonBytes(value) <= limit) return value;
+  if (jsonBytes('') > limit) return undefined;
+  if (jsonBytes(TRUNCATION_MARKER) > limit) return '';
+
+  let projected = '';
+  for (const character of value) {
+    if (jsonBytes(projected + character + TRUNCATION_MARKER) > limit) break;
+    projected += character;
+  }
+  return projected + TRUNCATION_MARKER;
+}
+
+function projectArray(value, budget, depth) {
+  const projected = [];
+  let used = 2;
+  for (const item of value.slice(0, RESULT_ITEM_LIMIT)) {
+    const separatorBytes = projected.length ? 1 : 0;
+    const child = projectValue(item, budget - used - separatorBytes, depth + 1);
+    if (child === undefined) continue;
+    const childBytes = jsonBytes(child);
+    if (used + separatorBytes + childBytes > budget) continue;
+    projected.push(child);
+    used += separatorBytes + childBytes;
+  }
+  return projected;
+}
+
+function projectObject(value, budget, depth, root = false) {
+  const projected = root ? { truncated: true } : {};
+  let used = jsonBytes(projected);
+  let propertyCount = root ? 1 : 0;
+
+  for (const [key, item] of Object.entries(value)) {
+    if (root && key === 'truncated') continue;
+    const separatorBytes = propertyCount ? 1 : 0;
+    const propertyBytes = separatorBytes + jsonBytes(key) + 1;
+    const child = projectValue(item, budget - used - propertyBytes, depth + 1);
+    if (child === undefined) continue;
+    const childBytes = jsonBytes(child);
+    if (used + propertyBytes + childBytes > budget) continue;
+    projected[key] = child;
+    used += propertyBytes + childBytes;
+    propertyCount += 1;
+  }
+  return projected;
+}
+
+function jsonBytes(value) {
+  const json = JSON.stringify(value);
+  return json === undefined ? Number.POSITIVE_INFINITY : Buffer.byteLength(json, 'utf8');
+}
+
+function boundedMessage(message) {
+  const singleLine = String(message).replace(/[\r\n\t]+/g, ' ').trim();
+  return singleLine.slice(0, MESSAGE_LIMIT) || 'Request failed';
+}
+
+function isObject(value) {
+  return value !== null && typeof value === 'object';
+}

package/src/mcp/tool-schema.js

@@ -0,0 +1,60 @@
+import * as z from 'zod/v4';
+
+export function jsonSchemaToZod(schema) {
+  if (Array.isArray(schema.type)) return nullableSchema(schema);
+  if (schema.enum) return z.enum(schema.enum);
+  if (schema.type === 'object') return objectToZod(schema);
+  if (schema.type === 'string') return stringToZod(schema);
+  if (schema.type === 'boolean') return z.boolean();
+  if (schema.type === 'number') return numberToZod(schema, false);
+  if (schema.type === 'integer') return numberToZod(schema, true);
+  if (schema.type === 'array') return arrayToZod(schema);
+  if (schema.type === 'null') return z.null();
+  throw new TypeError(`Unsupported JSON schema type: ${schema.type}`);
+}
+
+export function openObjectSchema() {
+  return z.looseObject({});
+}
+
+function stringToZod(schema) {
+  let converted = z.string();
+  if (schema.minLength !== undefined) converted = converted.min(schema.minLength);
+  if (schema.maxLength !== undefined) converted = converted.max(schema.maxLength);
+  if (schema.pattern !== undefined) converted = converted.regex(new RegExp(schema.pattern));
+  return converted;
+}
+
+function objectToZod(schema) {
+  const required = new Set(schema.required ?? []);
+  const shape = Object.fromEntries(
+    Object.entries(schema.properties ?? {}).map(([name, property]) => {
+      const converted = jsonSchemaToZod(property);
+      return [name, required.has(name) ? converted : converted.optional()];
+    })
+  );
+  return schema.additionalProperties === false ? z.strictObject(shape) : z.looseObject(shape);
+}
+
+function nullableSchema(schema) {
+  const types = schema.type;
+  if (types.length !== 2 || !types.includes('null')) {
+    throw new TypeError(`Unsupported JSON schema union: ${types.join(',')}`);
+  }
+  const valueType = types.find((type) => type !== 'null');
+  return jsonSchemaToZod({ ...schema, type: valueType }).nullable();
+}
+
+function numberToZod(schema, integer) {
+  let converted = integer ? z.number().int() : z.number();
+  if (schema.minimum !== undefined) converted = converted.min(schema.minimum);
+  if (schema.maximum !== undefined) converted = converted.max(schema.maximum);
+  return converted;
+}
+
+function arrayToZod(schema) {
+  let converted = z.array(jsonSchemaToZod(schema.items));
+  if (schema.minItems !== undefined) converted = converted.min(schema.minItems);
+  if (schema.maxItems !== undefined) converted = converted.max(schema.maxItems);
+  return converted;
+}

package/src/mcp-server.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import { callAgentTool, listAgentTools } from './agent-tools.js';
+import { ApplicationError } from './app/application-error.js';
+import { openFederatedGraphApplication } from './graphiti/federated-application.js';
+import {
+  GraphRuntimeConfigurationError,
+  resolveGraphRuntimeOptions
+} from './graphiti/runtime-config.js';
+import { runStdio } from './mcp/runtime.js';
+import { applicationErrorMessage } from './mcp/tool-result.js';
+
+await main(process.argv.slice(2)).catch((error) => {
+  process.stderr.write(`${startupMessage(error)}\n`);
+  process.exitCode = 1;
+});
+
+async function main(args) {
+  if (args.includes('--tools')) {
+    process.stdout.write(`${JSON.stringify(listAgentTools(), null, 2)}\n`);
+    return;
+  }
+  if (args.includes('--help') || args.includes('-h')) {
+    process.stdout.write(helpText());
+    return;
+  }
+
+  const { runtimeConfigPath } = resolveGraphRuntimeOptions(args, process.env);
+  if (args.includes('--call')) {
+    await runCall({ args, runtimeConfigPath });
+    return;
+  }
+  await runStdio({ runtimeConfigPath });
+}
+
+async function runCall({ args, runtimeConfigPath }) {
+  const app = openFederatedGraphApplication({ runtimeConfigPath });
+  try {
+    const result = await callAgentTool(
+      app,
+      requiredOption(args, '--call'),
+      parseInput(args)
+    );
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  } finally {
+    await app.close();
+  }
+}
+
+function option(args, flag) {
+  const index = args.indexOf(flag);
+  return index === -1 ? null : args[index + 1];
+}
+
+function requiredOption(args, flag) {
+  const value = option(args, flag);
+  if (!value) throw new TypeError(`Missing value for ${flag}`);
+  return value;
+}
+
+function parseInput(args) {
+  const raw = option(args, '--input');
+  return raw ? JSON.parse(raw) : {};
+}
+
+function startupMessage(error) {
+  if (error instanceof ApplicationError) return applicationErrorMessage(error);
+  if (error instanceof GraphRuntimeConfigurationError) return error.message;
+  return 'MCP server failed to start';
+}
+
+function helpText() {
+  return 'Usage: node src/mcp-server.js [--runtime-config <graph-runtime.json>]\n' +
+    '       node src/mcp-server.js --tools\n' +
+    '       node src/mcp-server.js --runtime-config <graph-runtime.json> ' +
+    '--call <tool> [--input <json>]\n';
+}

package/src/models.js

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,83 @@
+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/package-metadata.js

@@ -0,0 +1,6 @@
+import { readFileSync } from 'node:fs';
+
+const manifest = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+
+export const FULI_PACKAGE_NAME = manifest.name;
+export const FULI_VERSION = manifest.version;

package/src/project-rules.js

@@ -0,0 +1,33 @@
+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/canonical-json.js

@@ -0,0 +1,39 @@
+import { createHash } from 'node:crypto';
+
+export function canonicalJson(value) {
+  return JSON.stringify(canonicalValue(value, new Set()));
+}
+
+export function contentHash(value) {
+  return createHash('sha256').update(canonicalJson(value)).digest('hex');
+}
+
+function canonicalValue(value, ancestors) {
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return value;
+  if (typeof value === 'number') {
+    if (Number.isFinite(value)) return value;
+    throw new TypeError('Canonical JSON requires finite numbers');
+  }
+  if (typeof value !== 'object') {
+    throw new TypeError('Canonical JSON contains an unsupported value');
+  }
+  if (ancestors.has(value)) throw new TypeError('Canonical JSON cannot contain circular values');
+
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) return value.map((item) => canonicalValue(item, ancestors));
+    if (!isPlainObject(value)) {
+      throw new TypeError('Canonical JSON requires plain objects');
+    }
+    return Object.fromEntries(Object.keys(value).sort().map(
+      (key) => [key, canonicalValue(value[key], ancestors)]
+    ));
+  } finally {
+    ancestors.delete(value);
+  }
+}
+
+function isPlainObject(value) {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}

package/src/publication/outbox-service.js

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,75 @@
+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;
+}

package/src/publication/publication-envelope.js

@@ -0,0 +1,37 @@
+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
+  };
+}