fuli-context 0.2.0

package/src/lens/lens-query.js

@@ -0,0 +1,143 @@
+import { ApplicationError, ApplicationErrorCode } from '../app/application-error.js';
+import { FactScope } from '../models.js';
+import { requirePersonalSpace } from './lens-input.js';
+import {
+  BOUNDARY_PREDICATES,
+  BOUNDARY_PREFIXES,
+  compareLensFacts,
+  taskTokens
+} from './lens-query-ranking.js';
+import {
+  isInjectableFact,
+  projectSearchFact,
+  safePersonalEpisode
+} from './lens-query-projection.js';
+import { LensSearchQuery } from './lens-search-query.js';
+
+export { BOUNDARY_PREDICATES, BOUNDARY_PREFIXES };
+export {
+  DEFAULT_SEARCH_USER_CONTEXT_LIMIT,
+  MAX_SEARCH_USER_CONTEXT_LIMIT
+} from './lens-search-query.js';
+
+export class LensQuery extends LensSearchQuery {
+  getUserLens(input) {
+    return this.#getUserLens(input, true);
+  }
+
+  #getUserLens({
+    personalSpaceId,
+    task,
+    budget,
+    includeObserved = true,
+    includeSuggested = false,
+    includeRestricted = false
+  }, redactRelations) {
+    requirePersonalSpace(this.store, personalSpaceId);
+    validateTask(task);
+    validateBudget(budget);
+
+    const terms = taskTokens(task);
+    const allowRestricted = includeRestricted === true;
+    const facts = this.store.currentFacts(personalSpaceId)
+      .filter((fact) => fact.spaceId === personalSpaceId && fact.scope === FactScope.PERSONAL)
+      .filter((fact) => isInjectableFact(fact, {
+        includeObserved,
+        includeSuggested,
+        includeRestricted: allowRestricted
+      }))
+      .sort((left, right) => compareLensFacts(left, right, terms));
+    const selected = [];
+    const lines = [];
+    let bytes = 0;
+
+    for (const fact of facts) {
+      const line = formatFactLine(fact);
+      const nextBytes = bytes + (lines.length ? 1 : 0) + Buffer.byteLength(line, 'utf8');
+      if (nextBytes > budget) continue;
+      selected.push(fact);
+      lines.push(line);
+      bytes = nextBytes;
+    }
+
+    return {
+      personalSpaceId,
+      task,
+      text: lines.join('\n'),
+      facts: redactRelations
+        ? selected.map((fact) => {
+          const source = this.store.episodeEvidencePreview(
+            personalSpaceId,
+            fact.sourceEpisodeId,
+            { includeRestricted: allowRestricted, maxBodyBytes: 0 }
+          );
+          return projectSearchFact(
+            this.store,
+            fact,
+            source,
+            personalSpaceId,
+            new Map(),
+            allowRestricted
+          ).fact;
+        })
+        : selected,
+      estimatedTokens: bytes,
+      truncated: selected.length < facts.length
+    };
+  }
+
+  getUserLensView(input) {
+    return this.store.transaction(() => {
+      const lens = this.#getUserLens(input, false);
+      const entries = [];
+      for (const fact of lens.facts) {
+        const source = safePersonalEpisode(
+          this.store.episodeEvidencePreview(
+            lens.personalSpaceId,
+            fact.sourceEpisodeId,
+            { includeRestricted: input.includeRestricted === true, maxBodyBytes: 0 }
+          ),
+          lens.personalSpaceId,
+          input.includeRestricted === true
+        );
+        if (source) entries.push(projectLensViewEntry(fact, source));
+      }
+      return {
+        entries,
+        truncated: lens.truncated || entries.length < lens.facts.length
+      };
+    });
+  }
+
+}
+
+function validateTask(task) {
+  if (typeof task !== 'string') {
+    throw new ApplicationError(ApplicationErrorCode.VALIDATION, 'Task must be a string');
+  }
+}
+
+function validateBudget(budget) {
+  if (!Number.isInteger(budget) || budget <= 0) {
+    throw new ApplicationError(ApplicationErrorCode.VALIDATION, 'Budget must be a positive integer');
+  }
+}
+
+function formatFactLine(fact) {
+  return `${fact.subject} ${fact.predicate} ${fact.object} (${fact.status})`;
+}
+
+function projectLensViewEntry(fact, source) {
+  return {
+    subject: fact.subject,
+    predicate: fact.predicate,
+    object: fact.object,
+    status: fact.status,
+    validAt: fact.validAt,
+    source: {
+      kind: source.sourceKind,
+      uri: source.sourceUri,
+      createdAt: source.createdAt
+    }
+  };
+}

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

@@ -0,0 +1,93 @@
+import { detectSensitiveContent } from '../security/sensitive-content.js';
+
+export function projectCurrentFact(fact) {
+  return compactFact(fact);
+}
+
+export function isSafeResourceFact(fact) {
+  return compactFact(fact) !== null;
+}
+
+export function projectHistoryItem(item) {
+  const fact = compactFact(item.fact);
+  if (!fact) return null;
+  return {
+    current: item.current,
+    fact,
+    source: compactEpisode(item.sourceEpisode),
+    replacementFact: compactFact(item.replacementFact),
+    correctionEpisodes: item.correctionEpisodes.map(compactCorrection).filter(Boolean)
+  };
+}
+
+export function projectSubscription(subscription, space) {
+  if (![
+    space?.id,
+    space?.name,
+    space?.kind,
+    subscription?.mode,
+    subscription?.createdAt
+  ].every(isSafeResourceText)) return null;
+  const compactSpace = { id: space.id, name: space.name, kind: space.kind };
+  if (isSafeResourceText(space.description)) {
+    compactSpace.description = space.description;
+  }
+  return {
+    space: compactSpace,
+    mode: subscription.mode,
+    createdAt: subscription.createdAt
+  };
+}
+
+function compactFact(fact) {
+  if (!fact || ![
+    fact.id,
+    fact.subject,
+    fact.predicate,
+    fact.object,
+    fact.status,
+    fact.validAt
+  ].every(isSafeResourceText)) return null;
+  if (!Number.isFinite(fact.confidence) || fact.confidence < 0 || fact.confidence > 1) {
+    return null;
+  }
+  return {
+    id: fact.id,
+    subject: fact.subject,
+    predicate: fact.predicate,
+    object: fact.object,
+    status: fact.status,
+    confidence: fact.confidence,
+    validAt: fact.validAt
+  };
+}
+
+function compactEpisode(episode) {
+  if (!episode) return null;
+  if (![
+    episode.id,
+    episode.sourceKind,
+    episode.createdAt
+  ].every(isSafeResourceText)) return null;
+  if (!isSafeResourceText(episode.sourceUri, { nullable: true })) return null;
+  return {
+    id: episode.id,
+    kind: episode.sourceKind,
+    uri: episode.sourceUri,
+    createdAt: episode.createdAt
+  };
+}
+
+function compactCorrection(episode) {
+  const compact = compactEpisode(episode);
+  if (!compact || !isSafeResourceText(episode.metadata?.action)) return null;
+  return {
+    ...compact,
+    action: episode.metadata.action
+  };
+}
+
+export function isSafeResourceText(value, { nullable = false } = {}) {
+  if (value === null || value === undefined) return nullable;
+  return typeof value === 'string' && !detectSensitiveContent(value).restricted;
+}

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

@@ -0,0 +1,45 @@
+const EMPTY_ARRAY_BYTES = 2;
+const HISTORY_ENVELOPE_RESERVE_BYTES = 1024;
+
+export function selectCurrentFacts(facts, budgetBytes) {
+  const selected = [];
+  const lines = [];
+  let bytes = 0;
+  for (const fact of facts) {
+    const line = `${fact.subject} ${fact.predicate} ${fact.object} (${fact.status})`;
+    const nextBytes = bytes + (lines.length ? 1 : 0) + Buffer.byteLength(line, 'utf8');
+    if (nextBytes > budgetBytes) continue;
+    selected.push(fact);
+    lines.push(line);
+    bytes = nextBytes;
+  }
+  return {
+    facts: selected,
+    text: lines.join('\n'),
+    truncated: selected.length < facts.length
+  };
+}
+
+export function selectHistoryItems(items, { limit, budgetBytes }) {
+  const selected = [];
+  const itemsBudget = budgetBytes - HISTORY_ENVELOPE_RESERVE_BYTES;
+  let itemsBytes = EMPTY_ARRAY_BYTES;
+  let truncated = false;
+
+  for (const item of items) {
+    if (selected.length >= limit) {
+      truncated = true;
+      break;
+    }
+    const itemBytes = Buffer.byteLength(JSON.stringify(item), 'utf8');
+    const nextItemsBytes = itemsBytes + (selected.length ? 1 : 0) + itemBytes;
+    if (nextItemsBytes > itemsBudget) {
+      truncated = true;
+      continue;
+    }
+    selected.push(item);
+    itemsBytes = nextItemsBytes;
+  }
+
+  return { items: selected, itemsBytes, truncated };
+}

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

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

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

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