@hassangameryt/freeflow 0.4.0 → 0.6.0

package/pi-extension/src/context-virtualization/commands.ts

@@ -0,0 +1,111 @@
+import type { ContextStatus } from "./types.js";
+import type { ContextVirtualizationRuntime } from "./runtime.js";
+
+function formatStatus(
+  status: ContextStatus,
+  features: { contextVirtualization: boolean; conversationHistory: boolean },
+): string {
+  if (!status.available) {
+    return `Freeflow Context: unavailable${status.unavailableReason ? ` (${status.unavailableReason})` : ""}`;
+  }
+  return [
+    "Freeflow Context: available",
+    `Context Virtualization: ${features.contextVirtualization ? "enabled" : "disabled"}`,
+    `Conversation History: ${features.conversationHistory ? "enabled" : "disabled"}`,
+    `Session: ${status.sessionId}`,
+    `Branch: ${status.branchLeafId ?? "root"}`,
+    `Projections: full=${status.counts.full}, archived=${status.counts.archived}, retained=${status.counts.retained}`,
+    `Characters: original=${status.originalCharacters.toLocaleString("en-US")}, projected=${status.projectedCharacters.toLocaleString("en-US")}`,
+    `Availability: history-only=${status.historyOnly}, unresolved=${status.unresolved}`,
+  ].join("\n");
+}
+
+function formatList(status: ContextStatus): string {
+  if (!status.available) return formatStatus(status, { contextVirtualization: true, conversationHistory: false });
+  const items = status.items.filter((item) => item.mode === "archived");
+  if (items.length === 0) return "Context Virtualization: no archived projections in the active session branch.";
+
+  const lines = ["Context Virtualization: archived projections"];
+  for (const item of items) {
+    lines.push(
+      "",
+      `Ref: ${item.ref}`,
+      `Tool: ${item.toolName ?? "tool"}`,
+      `State: ${item.retained === undefined ? "archived" : "retained"}`,
+      `Original: ${item.originalCharacters.toLocaleString("en-US")} characters`,
+      `Projected: ${item.projectedCharacters.toLocaleString("en-US")} characters`,
+      `Availability: ${item.availability}`,
+    );
+    if (item.retained !== undefined) lines.push(`Retained: ${item.retained}`);
+  }
+  return lines.join("\n");
+}
+
+function refsFromArgs(args: string): string[] {
+  return args
+    .split(/[\s,]+/)
+    .map((value) => value.trim())
+    .filter(Boolean);
+}
+
+export async function handleContextCommand(
+  args: string | undefined,
+  ctx: any,
+  runtime: ContextVirtualizationRuntime | undefined,
+  enabled: boolean,
+  conversationHistoryEnabled = false,
+) {
+  const input = (args ?? "status").trim();
+  const [action = "status", ...rest] = input.split(/\s+/);
+  const normalized = action.toLowerCase();
+
+  if (!runtime) {
+    ctx.ui.notify("Context Virtualization is unavailable for this session.", "warning");
+    return { changed: false, error: "unavailable" };
+  }
+
+  if (normalized === "status") {
+    const status = await runtime.status();
+    ctx.ui.notify(
+      formatStatus(status, { contextVirtualization: enabled, conversationHistory: conversationHistoryEnabled }),
+      enabled || conversationHistoryEnabled ? "info" : "warning",
+    );
+    return { changed: false, status };
+  }
+
+  if (normalized === "list") {
+    const status = await runtime.status();
+    ctx.ui.notify(formatList(status), enabled ? "info" : "warning");
+    return { changed: false, status };
+  }
+
+  if (normalized === "restore") {
+    const refs = refsFromArgs(rest.join(" "));
+    if (!enabled) {
+      ctx.ui.notify("Context Virtualization is disabled by configuration; no projection state was changed.", "warning");
+      return { changed: false, error: "disabled" };
+    }
+    const result = await runtime.restore(refs, "user");
+    ctx.ui.notify(
+      result.message ?? `${result.status}: ${result.operation}`,
+      result.status === "ok" ? "info" : "warning",
+    );
+    return { changed: result.status === "ok", result };
+  }
+
+  if (normalized === "reset" && rest.join(" ").toLowerCase() === "all") {
+    if (!enabled) {
+      ctx.ui.notify("Context Virtualization is disabled by configuration; no projection state was changed.", "warning");
+      return { changed: false, error: "disabled" };
+    }
+    const result = await runtime.reset();
+    ctx.ui.notify(
+      result.message ?? `${result.status}: ${result.operation}`,
+      result.status === "ok" ? "info" : "warning",
+    );
+    return { changed: result.status === "ok", result };
+  }
+
+  ctx.ui.notify("Usage: /freeflow context [status|list|restore <ctx:entryId>...|reset all]", "warning");
+  return { changed: false, error: "invalid_action" };
+}

package/pi-extension/src/context-virtualization/projector.ts

@@ -0,0 +1,62 @@
+import { CONTEXT_REF_PREFIX, contextRefForEntry, type ContextProjection, type ContextSourceIdentity } from "./types.js";
+
+export function contentCharacters(content: unknown): number {
+  if (typeof content === "string") return content.length;
+  if (!Array.isArray(content)) return 0;
+  return content.reduce((total, part) => {
+    if (part?.type === "text" && typeof part.text === "string") return total + part.text.length;
+    if (part?.type === "image") return total + 16;
+    return total;
+  }, 0);
+}
+
+export function contextMarker(source: ContextSourceIdentity): { type: "text"; text: string } {
+  return {
+    type: "text",
+    text: `[context-ref: ${contextRefForEntry(source.entryId)}]`,
+  };
+}
+
+export function archiveContent(source: ContextSourceIdentity, retained?: string): string {
+  const marker = `[context archived: ${contextRefForEntry(source.entryId)}]`;
+  if (!retained) return marker;
+  return `${marker}\n\n<retained-context>\n${retained}\n</retained-context>`;
+}
+
+export function fullContent(source: ContextSourceIdentity, content: unknown[] = []): any[] {
+  return [...content, contextMarker(source)];
+}
+
+export function projectedContent(
+  source: ContextSourceIdentity,
+  content: unknown,
+  projection: ContextProjection,
+): any[] {
+  if (projection.mode === "archived") {
+    return [{ type: "text", text: archiveContent(source, projection.retained) }];
+  }
+  return fullContent(source, Array.isArray(content) ? content : [{ type: "text", text: String(content ?? "") }]);
+}
+
+export function projectToolResultMessage(
+  message: any,
+  source: ContextSourceIdentity,
+  projection: ContextProjection,
+): any {
+  return {
+    ...message,
+    content: projectedContent(source, message.content, projection),
+  };
+}
+
+export function projectedCharacters(
+  source: ContextSourceIdentity,
+  message: any,
+  projection: ContextProjection,
+): number {
+  return contentCharacters(projectedContent(source, message?.content, projection));
+}
+
+export function sourceReference(source: ContextSourceIdentity): string {
+  return `${CONTEXT_REF_PREFIX}${source.entryId}`;
+}

package/pi-extension/src/context-virtualization/runtime.ts

@@ -0,0 +1,406 @@
+import {
+  CONTEXT_PROJECTION_ENTRY,
+  CONTEXT_PROJECTION_VERSION,
+  contextRefForEntry,
+  entryIdFromContextRef,
+  type ContextAvailability,
+  type ContextListItem,
+  type ContextOperationResult,
+  type ContextProjection,
+  type ContextProjectionChange,
+  type ContextProjectionJournal,
+  type ContextProjectionResult,
+  type ContextProjectionState,
+  type ContextStatus,
+} from "./types.js";
+import { FreeflowContextRuntime } from "../freeflow-context/runtime.js";
+import type { ContextSourceIdentity, ResolvedContextSource } from "../freeflow-context/types.js";
+import { contentCharacters, projectToolResultMessage, projectedCharacters } from "./projector.js";
+import { replayProjectionEntries } from "./state.js";
+
+function cloneSource(source: ContextSourceIdentity): ContextSourceIdentity {
+  return { ...source };
+}
+
+function sourceProjection(state: ContextProjectionState | undefined): ContextProjection {
+  if (!state || state.mode === "full") return { mode: "full" };
+  return state.retained === undefined ? { mode: "archived" } : { mode: "archived", retained: state.retained };
+}
+
+function safeJsonEqual(left: unknown, right: unknown): boolean {
+  try {
+    return JSON.stringify(left) === JSON.stringify(right);
+  } catch {
+    return false;
+  }
+}
+
+function isDuplicate(values: string[]): string | undefined {
+  const seen = new Set<string>();
+  for (const value of values) {
+    if (seen.has(value)) return value;
+    seen.add(value);
+  }
+  return undefined;
+}
+
+export class ContextVirtualizationRuntime {
+  private readonly pi: any;
+  private readonly freeflowContext: FreeflowContextRuntime;
+  private ctx: any;
+  private sessionId = "current";
+  private branchLeafId: string | null | undefined;
+  private projectionState = new Map<string, ContextProjectionState>();
+  private available = true;
+  private unavailableReason: string | undefined;
+  private mutationQueue: Promise<unknown> = Promise.resolve();
+
+  constructor(pi: any, ctx: any, freeflowContext = new FreeflowContextRuntime(ctx)) {
+    this.pi = pi;
+    this.ctx = ctx;
+    this.freeflowContext = freeflowContext;
+  }
+
+  setContext(ctx: any): void {
+    this.ctx = ctx;
+    this.freeflowContext.setContext(ctx);
+  }
+
+  async recover(ctx = this.ctx, options: { preserveRequest?: boolean } = {}): Promise<boolean> {
+    this.ctx = ctx;
+    this.freeflowContext.setContext(ctx);
+    try {
+      this.sessionId = this.freeflowContext.sessionId();
+      this.branchLeafId = this.freeflowContext.branchLeafId();
+      this.projectionState = replayProjectionEntries(this.freeflowContext.branchEntries(), this.sessionId);
+      if (!options.preserveRequest) this.freeflowContext.clearRequest();
+      this.available = true;
+      this.unavailableReason = undefined;
+      return true;
+    } catch (error) {
+      this.available = false;
+      this.unavailableReason = error instanceof Error ? error.message : String(error);
+      this.freeflowContext.clearRequest();
+      return false;
+    }
+  }
+
+  isAvailable(): boolean {
+    return this.available;
+  }
+
+  isSourceFullyProjected(entryId: string): boolean {
+    if (!this.available) return true;
+    const projection = this.projectionState.get(entryId);
+    return !projection || projection.mode === "full";
+  }
+
+  async project(messages: any[], enabled: boolean): Promise<ContextProjectionResult> {
+    if (!enabled) {
+      this.freeflowContext.clearRequest();
+      return { messages, changed: false, available: true };
+    }
+
+    if (!(await this.recover(this.ctx))) {
+      return { messages, changed: false, available: false };
+    }
+
+    const sourcesByToolCallId = this.freeflowContext.resolver.toolResultSources();
+    const refs = new Map<string, ResolvedContextSource>();
+    let changed = false;
+    const projected = messages.map((message) => {
+      if (message?.role !== "toolResult" || typeof message.toolCallId !== "string") return message;
+      const source = sourcesByToolCallId.get(message.toolCallId);
+      if (!source) return message;
+
+      const ref = contextRefForEntry(source.source.entryId);
+      refs.set(ref, source);
+      const state = this.projectionState.get(source.source.entryId);
+      const projection = sourceProjection(state);
+      const nextMessage = projectToolResultMessage(message, source.source, projection);
+      if (!safeJsonEqual(nextMessage.content, message.content)) changed = true;
+      return nextMessage;
+    });
+
+    const request = this.freeflowContext.recordRequest(refs);
+    return {
+      messages: changed ? projected : messages,
+      changed,
+      available: true,
+      generation: request.generation,
+    };
+  }
+
+  async archive(targets: unknown): Promise<ContextOperationResult> {
+    try {
+      return await this.enqueue(() => this.archiveNow(targets));
+    } catch (error) {
+      return this.rejected("archive", `persistence_failed:${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  async restore(refs: unknown, actor: "model" | "user" = "model"): Promise<ContextOperationResult> {
+    try {
+      return await this.enqueue(() => this.restoreNow(refs, actor));
+    } catch (error) {
+      return this.rejected("restore", `persistence_failed:${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  async reset(): Promise<ContextOperationResult> {
+    try {
+      return await this.enqueue(async () => {
+        if (!this.available) return this.unavailable("reset");
+        const journal: ContextProjectionJournal = {
+          version: CONTEXT_PROJECTION_VERSION,
+          actor: "user",
+          reset: "all",
+        };
+        await this.persist(journal);
+        this.projectionState.clear();
+        return {
+          status: "ok",
+          operation: "reset",
+          changed: ["all"],
+          message: "All context projection decisions were reset on the active branch.",
+        };
+      });
+    } catch (error) {
+      return this.rejected("reset", `persistence_failed:${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  async status(limit = 50): Promise<ContextStatus> {
+    if (!this.available) {
+      return {
+        available: false,
+        unavailableReason: this.unavailableReason,
+        sessionId: this.sessionId,
+        branchLeafId: this.branchLeafId,
+        counts: { full: 0, archived: 0, retained: 0 },
+        originalCharacters: 0,
+        projectedCharacters: 0,
+        historyOnly: 0,
+        unresolved: 0,
+        items: [],
+      };
+    }
+
+    if (!(await this.recover(this.ctx, { preserveRequest: true }))) {
+      return this.status(limit);
+    }
+
+    const branchSources = this.freeflowContext.resolver.sourcesByEntryId();
+    const activeIds = this.freeflowContext.resolver.activeToolResultIds();
+    const items: ContextListItem[] = [];
+
+    for (const source of branchSources.values()) {
+      const state = this.projectionState.get(source.source.entryId);
+      const projection = sourceProjection(state);
+      items.push(this.listItem(source, projection, activeIds.has(source.source.entryId) ? "active" : "history-only"));
+    }
+
+    for (const state of this.projectionState.values()) {
+      if (branchSources.has(state.source.entryId)) continue;
+      const projection = sourceProjection(state);
+      items.push({
+        ref: contextRefForEntry(state.source.entryId),
+        entryId: state.source.entryId,
+        toolCallId: state.source.toolCallId,
+        toolName: state.source.toolName,
+        mode: projection.mode,
+        ...(projection.mode === "archived" && projection.retained !== undefined
+          ? { retained: projection.retained }
+          : {}),
+        originalCharacters: 0,
+        projectedCharacters: projection.mode === "archived" ? contentCharacters(projection.retained ?? "") : 0,
+        availability: "unresolved",
+      });
+    }
+
+    const counts = { full: 0, archived: 0, retained: 0 };
+    let originalCharacters = 0;
+    let projectedCharactersTotal = 0;
+    let historyOnly = 0;
+    let unresolved = 0;
+    for (const item of items) {
+      if (item.mode === "full") counts.full += 1;
+      else {
+        counts.archived += 1;
+        if (item.retained !== undefined) counts.retained += 1;
+      }
+      originalCharacters += item.originalCharacters;
+      projectedCharactersTotal += item.projectedCharacters;
+      if (item.availability === "history-only") historyOnly += 1;
+      if (item.availability === "unresolved") unresolved += 1;
+    }
+
+    return {
+      available: true,
+      sessionId: this.sessionId,
+      branchLeafId: this.branchLeafId,
+      counts,
+      originalCharacters,
+      projectedCharacters: projectedCharactersTotal,
+      historyOnly,
+      unresolved,
+      items: items.slice(-Math.max(1, limit)),
+    };
+  }
+
+  private async archiveNow(targets: unknown): Promise<ContextOperationResult> {
+    if (!this.available) return this.unavailable("archive");
+    if (!Array.isArray(targets) || targets.length === 0) {
+      return this.rejected("archive", "targets_required");
+    }
+    const normalizedRefs = targets.map((target) =>
+      target && typeof target === "object" ? entryIdFromContextRef((target as any).ref) : undefined,
+    );
+    const duplicate = isDuplicate(
+      normalizedRefs.flatMap((ref) => (ref === undefined ? [] : [contextRefForEntry(ref)])),
+    );
+    if (duplicate) return this.rejected("archive", `duplicate_reference:${duplicate}`);
+    const latestRequest = this.freeflowContext.latestRequest();
+    if (!latestRequest) return this.rejected("archive", "no_consumed_context_request");
+
+    const changes: ContextProjectionChange[] = [];
+    const retainedMeaning: Record<string, string> = {};
+    for (let index = 0; index < targets.length; index += 1) {
+      const target = targets[index];
+      if (!target || typeof target !== "object") return this.rejected("archive", `target_${index}_must_be_object`);
+      const ref = normalizedRefs[index];
+      if (!ref) return this.rejected("archive", `target_${index}_invalid_reference`);
+      const normalizedRef = contextRefForEntry(ref);
+      const source = latestRequest.refs.get(normalizedRef);
+      if (!source) return this.rejected("archive", `target_not_in_consumed_context:${normalizedRef}`);
+      const retainedValue = (target as any).retained;
+      if (retainedValue !== undefined && (typeof retainedValue !== "string" || retainedValue.trim() === "")) {
+        return this.rejected("archive", `target_${index}_retained_must_be_non_empty`);
+      }
+      const retained = typeof retainedValue === "string" ? retainedValue.trim() : undefined;
+      changes.push({
+        source: cloneSource(source.source),
+        projection: retained === undefined ? { mode: "archived" } : { mode: "archived", retained },
+      });
+      if (retained !== undefined) retainedMeaning[normalizedRef] = retained;
+    }
+
+    await this.persist({ version: CONTEXT_PROJECTION_VERSION, actor: "model", changes });
+    for (const change of changes) {
+      this.projectionState.set(change.source.entryId, {
+        source: cloneSource(change.source),
+        ...change.projection,
+      });
+    }
+    return {
+      status: "ok",
+      operation: "archive",
+      changed: changes.map((change) => contextRefForEntry(change.source.entryId)),
+      message: `Archived ${changes.length} tool result${changes.length === 1 ? "" : "s"} from future context projections.`,
+      ...(Object.keys(retainedMeaning).length > 0 ? { retained: retainedMeaning } : {}),
+    };
+  }
+
+  private async restoreNow(refs: unknown, actor: "model" | "user"): Promise<ContextOperationResult> {
+    if (!this.available) return this.unavailable("restore");
+    if (!Array.isArray(refs) || refs.length === 0) return this.rejected("restore", "refs_required");
+    const normalizedRefs = refs.map((ref) => entryIdFromContextRef(ref));
+    const duplicate = isDuplicate(
+      normalizedRefs.flatMap((ref) => (ref === undefined ? [] : [contextRefForEntry(ref)])),
+    );
+    if (duplicate) return this.rejected("restore", `duplicate_reference:${duplicate}`);
+
+    const changes: ContextProjectionChange[] = [];
+    const availability: Record<string, ContextAvailability> = {};
+    const activeIds = this.freeflowContext.resolver.activeToolResultIds();
+    const latestRequest = this.freeflowContext.latestRequest();
+    for (let index = 0; index < refs.length; index += 1) {
+      const ref = normalizedRefs[index];
+      if (!ref) return this.rejected("restore", `ref_${index}_invalid_reference`);
+      const normalizedRef = contextRefForEntry(ref);
+      const current = this.projectionState.get(ref);
+      if (!current) return this.rejected("restore", `reference_not_archived:${normalizedRef}`);
+      if (actor === "model" && !latestRequest?.refs.has(normalizedRef)) {
+        return this.rejected("restore", `target_not_in_consumed_context:${normalizedRef}`);
+      }
+      changes.push({ source: cloneSource(current.source), projection: { mode: "full" } });
+      let availabilityValue: ContextAvailability;
+      if (latestRequest?.refs.has(normalizedRef) || activeIds.has(current.source.entryId)) {
+        availabilityValue = "active";
+      } else {
+        availabilityValue = "history-only";
+      }
+      availability[normalizedRef] = availabilityValue;
+    }
+
+    await this.persist({ version: CONTEXT_PROJECTION_VERSION, actor, changes });
+    for (const change of changes) {
+      this.projectionState.set(change.source.entryId, {
+        source: cloneSource(change.source),
+        mode: "full",
+      });
+    }
+    return {
+      status: "ok",
+      operation: "restore",
+      changed: changes.map((change) => contextRefForEntry(change.source.entryId)),
+      availability,
+      message: `Restored ${changes.length} projection${changes.length === 1 ? "" : "s"} to full content.`,
+    };
+  }
+
+  private listItem(
+    source: ResolvedContextSource,
+    projection: ContextProjection,
+    availability: ContextAvailability,
+  ): ContextListItem {
+    const item: ContextListItem = {
+      ref: contextRefForEntry(source.source.entryId),
+      entryId: source.source.entryId,
+      toolCallId: source.source.toolCallId,
+      toolName: source.source.toolName,
+      mode: projection.mode,
+      originalCharacters: contentCharacters(source.message?.content),
+      projectedCharacters: projectedCharacters(source.source, source.message, projection),
+      availability,
+    };
+    if (projection.mode === "archived" && projection.retained !== undefined) {
+      item.retained = projection.retained;
+    }
+    return item;
+  }
+
+  private rejected(operation: ContextOperationResult["operation"], message: string): ContextOperationResult {
+    return { status: "rejected", operation, changed: [], message };
+  }
+
+  private unavailable(operation: ContextOperationResult["operation"]): ContextOperationResult {
+    return {
+      status: "unavailable",
+      operation,
+      changed: [],
+      message: this.unavailableReason ?? "context_virtualization_unavailable",
+    };
+  }
+
+  private persist(journal: ContextProjectionJournal): void | Promise<void> {
+    let append: ((type: string, data: ContextProjectionJournal) => unknown) | undefined;
+    if (typeof this.pi?.appendEntryDurable === "function") {
+      append = this.pi.appendEntryDurable;
+    } else if (typeof this.pi?.appendEntry === "function") {
+      append = this.pi.appendEntry;
+    }
+    if (!append) throw new Error("The Pi host does not expose a session entry persistence method.");
+    const result = append.call(this.pi, CONTEXT_PROJECTION_ENTRY, journal);
+    if (result && typeof result.then === "function") return result;
+  }
+
+  private enqueue<T>(task: () => Promise<T>): Promise<T> {
+    const run = this.mutationQueue.then(task);
+    this.mutationQueue = run.then(
+      () => undefined,
+      () => undefined,
+    );
+    return run;
+  }
+}

package/pi-extension/src/context-virtualization/state.ts

@@ -0,0 +1,79 @@
+import {
+  CONTEXT_PROJECTION_ENTRY,
+  CONTEXT_PROJECTION_VERSION,
+  type ContextProjectionJournal,
+  type ContextProjectionState,
+  isRecord,
+} from "./types.js";
+
+type ProjectionLike = {
+  mode: "full" | "archived";
+  retained?: unknown;
+};
+
+function isProjection(value: unknown): value is ProjectionLike {
+  if (!isRecord(value) || (value.mode !== "full" && value.mode !== "archived")) return false;
+  if (value.mode === "archived" && value.retained !== undefined && typeof value.retained !== "string") return false;
+  return true;
+}
+
+function isJournal(value: unknown): value is ContextProjectionJournal {
+  if (!isRecord(value) || value.version !== CONTEXT_PROJECTION_VERSION) return false;
+  if (value.actor !== "model" && value.actor !== "user") return false;
+  if (value.reset !== undefined && value.reset !== "all") return false;
+  if (value.changes !== undefined && !Array.isArray(value.changes)) return false;
+  return true;
+}
+
+export function replayProjectionEntries(
+  entries: readonly any[],
+  sessionId: string,
+): Map<string, ContextProjectionState> {
+  const state = new Map<string, ContextProjectionState>();
+
+  for (const entry of entries) {
+    if (entry?.type !== "custom" || entry.customType !== CONTEXT_PROJECTION_ENTRY) continue;
+    const data = entry.data;
+    if (!isJournal(data)) continue;
+
+    if (data.reset === "all") {
+      state.clear();
+    }
+
+    for (const change of data.changes ?? []) {
+      if (!isRecord(change) || !isRecord(change.source) || !isProjection(change.projection)) continue;
+      if (change.source.sessionId !== sessionId || typeof change.source.entryId !== "string") continue;
+      if (change.projection.mode === "archived" && change.projection.retained !== undefined) {
+        state.set(change.source.entryId, {
+          source: { ...change.source },
+          mode: "archived",
+          retained: change.projection.retained,
+        });
+      } else if (change.projection.mode === "archived") {
+        state.set(change.source.entryId, {
+          source: { ...change.source },
+          mode: "archived",
+        });
+      } else {
+        state.set(change.source.entryId, {
+          source: { ...change.source },
+          mode: "full",
+        });
+      }
+    }
+  }
+
+  return state;
+}
+
+export function cloneProjectionState(state: Map<string, ContextProjectionState>) {
+  return new Map(
+    [...state.entries()].map(([entryId, projection]) => [
+      entryId,
+      {
+        ...projection,
+        source: { ...projection.source },
+      },
+    ]),
+  );
+}