@hassangameryt/freeflow 0.5.0 → 0.7.0

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 },
+      },
+    ]),
+  );
+}

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

@@ -0,0 +1,92 @@
+import type { ContextSourceIdentity } from "../freeflow-context/types.js";
+
+export { CONTEXT_REF_PREFIX, contextRefForEntry, entryIdFromContextRef } from "../freeflow-context/types.js";
+export type {
+  ContextRequestSnapshot,
+  ContextSourceKind,
+  ContextSourceIdentity,
+  ProjectedContextSource,
+  ResolvedContextEntry,
+  ResolvedContextSource,
+  SourceProjectionOutcome,
+} from "../freeflow-context/types.js";
+
+export const CONTEXT_PROJECTION_ENTRY = "freeflow-context-projection";
+export const CONTEXT_PROJECTION_VERSION = 1 as const;
+
+export type ContextProjectionMode = "full" | "archived";
+export type ContextProjectionActor = "model" | "user";
+
+export type ContextProjection = { mode: "full" } | { mode: "archived"; retained?: string };
+
+export type ContextProjectionState = ContextProjection & {
+  source: ContextSourceIdentity;
+};
+
+export type ContextProjectionChange = {
+  source: ContextSourceIdentity;
+  projection: ContextProjection;
+};
+
+export type ContextProjectionJournal = {
+  version: typeof CONTEXT_PROJECTION_VERSION;
+  actor: ContextProjectionActor;
+  changes?: ContextProjectionChange[];
+  reset?: "all";
+};
+
+export type ContextProjectionResult = {
+  messages: any[];
+  changed: boolean;
+  available: boolean;
+  generation?: number;
+};
+
+export type ContextAvailability = "active" | "history-only" | "unresolved";
+
+export type ContextListItem = {
+  ref: string;
+  entryId: string;
+  toolCallId?: string;
+  toolName?: string;
+  mode: ContextProjectionMode;
+  retained?: string;
+  originalCharacters: number;
+  projectedCharacters: number;
+  availability: ContextAvailability;
+};
+
+export type ContextStatus = {
+  available: boolean;
+  unavailableReason?: string;
+  sessionId: string;
+  branchLeafId?: string | null;
+  counts: {
+    full: number;
+    archived: number;
+    retained: number;
+  };
+  originalCharacters: number;
+  projectedCharacters: number;
+  historyOnly: number;
+  unresolved: number;
+  items: ContextListItem[];
+};
+
+export type ContextOperationResult = {
+  status: "ok" | "rejected" | "unavailable";
+  operation: "archive" | "restore" | "reset";
+  changed: string[];
+  message?: string;
+  retained?: Record<string, string>;
+  availability?: Record<string, ContextAvailability>;
+};
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function projectionCharacters(projection: ContextProjection): number {
+  if (projection.mode === "full") return 0;
+  return projection.retained?.length ?? 0;
+}

package/pi-extension/src/conversation-history/passages.ts

@@ -0,0 +1,81 @@
+export const PASSAGE_TARGET_CHARACTERS = 2_000;
+export const PASSAGE_OVERLAP_CHARACTERS = 200;
+export const SNIPPET_MAX_CHARACTERS = 400;
+
+export type TextPassage = {
+  text: string;
+  start: number;
+  end: number;
+  tokens: string[];
+  length: number;
+};
+
+export function normalizeText(value: string): string {
+  return value.normalize("NFKC").toLocaleLowerCase().replace(/\s+/g, " ").trim();
+}
+
+export function tokenize(value: string): string[] {
+  return normalizeText(value).match(/[\p{L}\p{N}_]+(?:[./:@#$%+-][\p{L}\p{N}_]+)*/gu) ?? [];
+}
+
+export function unique(values: readonly string[]): string[] {
+  return [...new Set(values)];
+}
+
+export function throwIfAborted(signal?: AbortSignal): void {
+  if (!signal?.aborted) return;
+  const error = new Error("conversation_history_search_cancelled");
+  error.name = "AbortError";
+  throw error;
+}
+
+function passageEnd(text: string, start: number): number {
+  const target = Math.min(text.length, start + PASSAGE_TARGET_CHARACTERS);
+  if (target === text.length) return target;
+  const paragraphBreak = text.lastIndexOf("\n\n", target);
+  if (paragraphBreak > start + PASSAGE_TARGET_CHARACTERS / 2) return paragraphBreak + 2;
+  const lineBreak = text.lastIndexOf("\n", target);
+  if (lineBreak > start + PASSAGE_TARGET_CHARACTERS / 2) return lineBreak + 1;
+  return target;
+}
+
+export function splitTextIntoPassages(text: string, signal?: AbortSignal): TextPassage[] {
+  throwIfAborted(signal);
+  if (text.length <= PASSAGE_TARGET_CHARACTERS) {
+    return [{ text, start: 0, end: text.length, tokens: tokenize(text), length: Math.max(1, tokenize(text).length) }];
+  }
+  const result: TextPassage[] = [];
+  let start = 0;
+  while (start < text.length) {
+    throwIfAborted(signal);
+    const end = passageEnd(text, start);
+    const passageText = text.slice(start, end);
+    const tokens = tokenize(passageText);
+    result.push({ text: passageText, start, end, tokens, length: Math.max(1, tokens.length) });
+    if (end >= text.length) break;
+    start = Math.max(start + 1, end - PASSAGE_OVERLAP_CHARACTERS);
+  }
+  return result;
+}
+
+export function snippet(text: string, phrase: string, terms: readonly string[]): string {
+  if (text.length <= SNIPPET_MAX_CHARACTERS) return text;
+  const lower = text.toLocaleLowerCase();
+  const phraseIndex = phrase ? lower.indexOf(phrase) : -1;
+  const termIndex =
+    phraseIndex >= 0
+      ? phraseIndex
+      : terms.reduce((best, term) => {
+          const index = lower.indexOf(term);
+          return index >= 0 && (best < 0 || index < best) ? index : best;
+        }, -1);
+  const center = termIndex >= 0 ? termIndex : 0;
+  let start = Math.max(0, center - Math.floor(SNIPPET_MAX_CHARACTERS / 3));
+  const end = Math.min(text.length, start + SNIPPET_MAX_CHARACTERS);
+  if (end - start < SNIPPET_MAX_CHARACTERS) start = Math.max(0, end - SNIPPET_MAX_CHARACTERS);
+  const prefix = start > 0 ? "…" : "";
+  const suffix = end < text.length ? "…" : "";
+  const available = SNIPPET_MAX_CHARACTERS - prefix.length - suffix.length;
+  const body = text.slice(start, start + available);
+  return `${prefix}${body}${suffix}`;
+}