@narumitw/pi-inspect 0.0.0-stage → 0.2.0

package/src/extension.ts

@@ -0,0 +1,259 @@
+import { randomUUID } from "node:crypto";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { ancestry } from "./ancestry.js";
+import { Collector } from "./collector.js";
+import { SessionFeed } from "./feed.js";
+import { recordedLeaf } from "./identity.js";
+import type { SkillView } from "./model.js";
+import { branch, detail } from "./projection.js";
+import { startServer, type ViewerServer } from "./server.js";
+
+interface Owner {
+  controller: AbortController;
+  generation: string;
+  feed?: SessionFeed;
+  ctx: ExtensionContext;
+  collector?: Collector;
+  skills: SkillView[];
+  server?: ViewerServer;
+  opening?: Promise<void>;
+}
+export interface Dependencies {
+  start: typeof startServer;
+  launch(pi: ExtensionAPI, url: string, signal: AbortSignal): Promise<boolean>;
+}
+const defaults: Dependencies = {
+  start: startServer,
+  async launch(pi, url, signal) {
+    const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer.exe" : "xdg-open";
+    const result = await pi.exec(command, [url], { signal, timeout: 5000 });
+    return result.code === 0 && !result.killed;
+  },
+};
+
+export function registerInspector(pi: ExtensionAPI, deps: Dependencies = defaults): void {
+  const owners = new Map<ExtensionContext["sessionManager"], Owner>();
+  const epochs = new WeakMap<ExtensionContext["sessionManager"], object>();
+  function epochFor(ctx: ExtensionContext): object {
+    let epoch = epochs.get(ctx.sessionManager);
+    if (!epoch) {
+      epoch = {};
+      epochs.set(ctx.sessionManager, epoch);
+    }
+    return epoch;
+  }
+  const alive = (owner: Owner) => !owner.controller.signal.aborted && owners.get(owner.ctx.sessionManager) === owner;
+  async function stop(ctx: ExtensionContext): Promise<void> {
+    const owner = owners.get(ctx.sessionManager);
+    if (!owner) return;
+    owners.delete(ctx.sessionManager);
+    owner.controller.abort();
+    owner.feed?.close();
+    await owner.server?.close();
+    await owner.opening;
+    owner.collector = undefined;
+  }
+  function ownerFor(ctx: ExtensionContext): Owner {
+    epochFor(ctx);
+    let owner = owners.get(ctx.sessionManager);
+    if (!owner) {
+      owner = { controller: new AbortController(), generation: randomUUID(), ctx, skills: [] };
+      owners.set(ctx.sessionManager, owner);
+    }
+    owner.ctx = ctx;
+    return owner;
+  }
+  function changed(ctx: ExtensionContext, structural = true): Owner | undefined {
+    const owner = owners.get(ctx.sessionManager);
+    if (!owner || !alive(owner)) return;
+    owner.ctx = ctx;
+    owner.feed?.changed(structural);
+    return owner;
+  }
+  pi.on("session_start", async (_event, ctx) => {
+    const epoch = {};
+    epochs.set(ctx.sessionManager, epoch);
+    await stop(ctx);
+    if (epochs.get(ctx.sessionManager) === epoch) ownerFor(ctx);
+  });
+  pi.on("session_shutdown", async (_event, ctx) => {
+    epochs.delete(ctx.sessionManager);
+    await stop(ctx);
+  });
+  // Observation only: never return or mutate messages/payload; later hooks may still transform them.
+  pi.on("context_with_system", (event, ctx) => {
+    const owner = owners.get(ctx.sessionManager);
+    if (owner?.collector && alive(owner)) {
+      owner.ctx = ctx;
+      owner.feed?.observeContext(event.messages);
+    }
+  });
+  pi.on("before_provider_request", (event, ctx) => {
+    const owner = owners.get(ctx.sessionManager);
+    if (owner?.collector && alive(owner)) owner.feed?.observePayload(event.payload);
+  });
+  pi.on("message_end", (_event, ctx) => {
+    changed(ctx);
+  });
+  pi.on("session_tree", (_event, ctx) => {
+    changed(ctx);
+  });
+  pi.on("session_compact", (_event, ctx) => {
+    changed(ctx);
+  });
+  pi.on("session_info_changed", (_event, ctx) => {
+    changed(ctx);
+  });
+  pi.on("model_select", (_event, ctx) => {
+    changed(ctx);
+  });
+  pi.on("thinking_level_select", (_event, ctx) => {
+    changed(ctx);
+  });
+  function executionAnchor(ctx: ExtensionContext, rawId: string): string | null {
+    const index = owners.get(ctx.sessionManager)?.feed?.index();
+    const leaf = recordedLeaf(ctx.sessionManager, index?.duplicates);
+    const entry = ctx.sessionManager.getLeafEntry();
+    if (leaf && entry?.type === "message" && entry.message.role === "assistant") return leaf;
+    return (
+      (leaf ? ancestry(ctx.sessionManager, leaf, index).path : [])
+        .slice()
+        .reverse()
+        .find(
+          (entry) =>
+            entry.type === "message" &&
+            entry.message.role === "assistant" &&
+            (Array.isArray(entry.message.content) ? entry.message.content : []).some(
+              (block) => block.type === "toolCall" && block.id === rawId,
+            ),
+        )?.id ?? leaf
+    );
+  }
+  pi.on("tool_execution_start", (event, ctx) => {
+    const owner = owners.get(ctx.sessionManager);
+    owner?.collector?.start(event, executionAnchor(ctx, event.toolCallId));
+    changed(ctx, false);
+  });
+  pi.on("tool_execution_update", (event, ctx) => {
+    const owner = owners.get(ctx.sessionManager);
+    if (owner?.collector?.update(event, recordedLeaf(ctx.sessionManager, owner?.feed?.index().duplicates)))
+      changed(ctx, false);
+  });
+  pi.on("tool_execution_end", (event, ctx) => {
+    const owner = owners.get(ctx.sessionManager);
+    owner?.collector?.end(event, executionAnchor(ctx, event.toolCallId));
+    changed(ctx, false);
+  });
+  pi.on("agent_settled", (_event, ctx) => {
+    owners.get(ctx.sessionManager)?.collector?.settle();
+    changed(ctx, false);
+  });
+
+  async function open(owner: Owner, ctx: ExtensionCommandContext): Promise<void> {
+    try {
+      if (!owner.server) {
+        const accepted = await ctx.ui.confirm(
+          "Open Session Inspector?",
+          "Serve this session's prompts, code and tool outputs to a local browser and record bounded context, provider payload and child results in memory? Redaction is incomplete. Nothing is uploaded or saved.",
+          { signal: owner.controller.signal },
+        );
+        if (!alive(owner) || !accepted) return;
+        const options = ctx.getSystemPromptOptions();
+        owner.skills = (options.skills ?? [])
+          .slice(0, 257) // One sentinel lets the snapshot disclose an incomplete catalog.
+          .map((s) => ({ name: s.name, path: s.filePath, description: s.description }));
+        owner.collector = new Collector();
+        owner.feed = new SessionFeed({
+          pi,
+          context: () => owner.ctx,
+          collector: owner.collector,
+          skills: owner.skills,
+          generation: owner.generation,
+          signal: owner.controller.signal,
+          invalidate: (revision) => {
+            if (alive(owner)) owner.server?.invalidate(revision);
+          },
+        });
+        const server = await deps.start({
+          generation: owner.generation,
+          signal: owner.controller.signal,
+          snapshot: () => owner.feed?.snapshot(),
+          branch: (id, offset) => branch(ctx.sessionManager, id, offset, owner.skills, owner.feed?.index()),
+          detail: (id, leaf) =>
+            detail(ctx.sessionManager, id, leaf, owner.collector ?? new Collector(), owner.feed?.index()),
+        });
+        if (!alive(owner)) {
+          await server.close();
+          return;
+        }
+        owner.server = server;
+        owner.feed.start();
+      }
+      if (!alive(owner)) return;
+      const url = owner.server.url;
+      let launched = false;
+      try {
+        launched = await deps.launch(pi, url, owner.controller.signal);
+      } catch {
+        /* URL fallback; no command stderr or token logging. */
+      }
+      if (!alive(owner)) return;
+      ctx.ui.notify(
+        `${launched ? "Session Inspector" : "Browser unavailable; open privately"}:\n${url}\n/inspect stop revokes this URL.`,
+        launched ? "info" : "warning",
+      );
+    } catch {
+      if (!alive(owner)) return;
+      owner.collector = undefined;
+      owner.feed?.close();
+      owner.feed = undefined;
+      await owner.server?.close();
+      owner.server = undefined;
+      if (alive(owner))
+        ctx.ui.notify(
+          "Could not open Session Inspector. Build its browser assets first; see the local README.",
+          "error",
+        );
+    }
+  }
+
+  const command: Parameters<ExtensionAPI["registerCommand"]>[1] = {
+    description: "Open a private, read-only live session web inspector",
+    getArgumentCompletions: (prefix) =>
+      ["stop"].filter((s) => s.startsWith(prefix)).map((value) => ({ value, label: value })),
+    handler: async (args, ctx) => {
+      const route = args.trim();
+      if (route !== "" && route !== "stop") {
+        if (ctx.hasUI) {
+          ctx.ui.notify("Usage: /inspect [stop]", "warning");
+          return;
+        }
+        throw new Error("Usage: /inspect [stop]");
+      }
+      if (route === "stop") {
+        const epoch = epochFor(ctx);
+        await stop(ctx);
+        if (ctx.hasUI && epochs.get(ctx.sessionManager) === epoch)
+          ctx.ui.notify("Session Inspector stopped; URL revoked.", "info");
+        return;
+      }
+      if (ctx.mode !== "tui") {
+        if (ctx.hasUI) {
+          ctx.ui.notify("Opening Session Inspector requires TUI mode. Stop remains available.", "warning");
+          return;
+        }
+        throw new Error("Opening Session Inspector requires TUI mode.");
+      }
+      const owner = ownerFor(ctx);
+      if (owner.opening) return;
+      owner.opening = open(owner, ctx);
+      try {
+        await owner.opening;
+      } finally {
+        owner.opening = undefined;
+      }
+    },
+  };
+  pi.registerCommand("inspect", command);
+  pi.registerCommand("session-inspector", command); // Compatibility route, same ownership and mode guards.
+}

package/src/feed.ts

@@ -0,0 +1,145 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { Collector } from "./collector.js";
+import { captureContext } from "./context.js";
+import { EntryIndex } from "./entry-index.js";
+import { recordedLeaf } from "./identity.js";
+import type { ContextComposition, SkillView, Snapshot } from "./model.js";
+import { capture, displayText, readSessionName } from "./privacy.js";
+import { snapshot } from "./projection.js";
+
+export class SessionFeed {
+  private dirty = true;
+  private observed?: ContextComposition;
+  private providerObservation?: Snapshot["providerObservation"];
+  observeContext(messages: readonly unknown[]): void {
+    if (this.closed || this.options.signal.aborted) return;
+    this.observed = captureContext(
+      messages,
+      "observed-pi-context",
+      recordedLeaf(this.options.context().sessionManager, this.index().duplicates),
+    );
+    this.observed.observedAt = Date.now();
+    this.changed(false);
+  }
+  observePayload(payload: unknown): void {
+    if (this.closed || this.options.signal.aborted) return;
+    // No public request identity associates this callback with a turn; warming/retries use it too.
+    this.providerObservation = { observedAt: Date.now(), data: capture(payload, 65536) };
+    this.changed(false);
+  }
+  private indexed?: EntryIndex;
+  private closed = false;
+  index(): EntryIndex {
+    if (this.closed || this.options.signal.aborted) throw new Error("Inspector stopped");
+    if (!this.indexed) this.indexed = new EntryIndex(this.options.context().sessionManager.getEntries());
+    return this.indexed;
+  }
+  private cached?: Snapshot;
+  private revision = 0;
+  private stamp = "";
+  private notification?: ReturnType<typeof setTimeout>;
+  private poll?: ReturnType<typeof setInterval>;
+  constructor(
+    private readonly options: {
+      pi: ExtensionAPI;
+      context(): ExtensionContext;
+      collector: Collector;
+      skills: SkillView[];
+      generation: string;
+      signal: AbortSignal;
+      invalidate(revision: number): void;
+    },
+  ) {}
+  private stateStamp(): string {
+    const ctx = this.options.context();
+    const manager = ctx.sessionManager;
+    const tools = this.options.pi.getAllTools();
+    // Public SDK method, omitted from the current ReadonlySessionManager type; readonly adapters may lack it.
+    const counted = manager as typeof manager & { getEntryCount?: () => number };
+    const count = typeof counted.getEntryCount === "function" ? counted.getEntryCount() : manager.getEntries().length;
+    return JSON.stringify({
+      count,
+      leaf: recordedLeaf(manager),
+      name: readSessionName(manager),
+      active: this.options.pi.getActiveTools(),
+      toolCount: tools.length,
+      tools: tools.slice(0, 256).map((tool) => ({
+        name: tool.name,
+        exposure: tool.exposure,
+        namespace: tool.namespace?.name,
+        description: displayText(tool.description).slice(0, 512),
+        schema: capture(tool.parameters, 2048),
+      })),
+    });
+  }
+  start(): void {
+    if (this.options.signal.aborted || this.poll) return;
+    this.stamp = this.stateStamp();
+    this.poll = setInterval(() => {
+      if (this.options.signal.aborted) return;
+      try {
+        const next = this.stateStamp();
+        if (next !== this.stamp) {
+          this.stamp = next;
+          this.changed(true);
+        }
+      } catch {
+        this.changed(true);
+      } // Context failures must not escape a timer callback.
+    }, 1000);
+    this.options.signal.addEventListener("abort", this.close, { once: true });
+  }
+  changed(structural: boolean): void {
+    if (this.options.signal.aborted) return;
+    if (structural) {
+      this.dirty = true;
+      this.indexed = undefined;
+    }
+    if (!this.notification)
+      this.notification = setTimeout(() => {
+        this.notification = undefined;
+        if (!this.options.signal.aborted) this.options.invalidate(++this.revision);
+      }, 250);
+  }
+  snapshot(): Snapshot {
+    if (this.closed || this.options.signal.aborted) throw new Error("Inspector stopped");
+    if (!this.cached || this.dirty) {
+      const ctx = this.options.context();
+      this.cached = snapshot(
+        ctx.sessionManager,
+        this.options.collector,
+        this.options.generation,
+        this.revision,
+        ctx.getSystemPrompt(),
+        this.options.pi.getAllTools(),
+        this.options.pi.getActiveTools(),
+        this.options.skills,
+        this.index(),
+        this.observed,
+      );
+      this.cached.calls = []; // Do not retain evicted live results inside the static cache.
+      this.dirty = false;
+    }
+    return {
+      ...this.cached,
+      revision: this.revision,
+      context: this.observed ?? this.cached.context,
+      providerObservation: this.providerObservation,
+      calls: this.options.collector.list(),
+      droppedCalls: this.options.collector.dropped,
+      invalidCallEvents: this.options.collector.invalidEvents,
+    };
+  }
+  close = (): void => {
+    this.closed = true;
+    clearTimeout(this.notification);
+    clearInterval(this.poll);
+    this.notification = undefined;
+    this.poll = undefined;
+    this.options.signal.removeEventListener("abort", this.close);
+    this.cached = undefined;
+    this.indexed = undefined;
+    this.observed = undefined;
+    this.providerObservation = undefined;
+  };
+}

package/src/identity.ts

@@ -0,0 +1,112 @@
+import type { ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
+import { systemMessageIssue } from "./system-message.js";
+
+export const MESSAGE_BLOCKS = 2048;
+
+export function structuralIssue(entry: SessionEntry | undefined): string | undefined {
+  if (typeof entry?.id !== "string" || !entry.id.length) return "missing, empty or non-string entry id";
+  if (entry.id.length > 512) return "over-budget entry id";
+  if (typeof entry.parentId === "string" && entry.parentId.length > 512) return "over-budget parent id";
+  if (entry.type === "label" && entry.label !== undefined && typeof entry.label !== "string")
+    return "non-string stored label";
+  if (entry.parentId !== null && (typeof entry.parentId !== "string" || !entry.parentId.length))
+    return "missing, empty or non-string parent id";
+  if (entry.type === "session_info" && entry.name !== undefined && typeof entry.name !== "string")
+    return "non-string stored session name";
+  if (typeof entry.type !== "string" || !entry.type.length) return "missing, empty or non-string entry type";
+  if (entry.type === "message" && (typeof entry.message?.role !== "string" || !entry.message.role.length))
+    return "missing, empty or non-string message role";
+  if (typeof entry.timestamp !== "string") return "non-string entry timestamp";
+  if (entry.timestamp.length > 512) return "over-budget entry timestamp";
+  return undefined;
+}
+
+export function identityIssue(entry: SessionEntry | undefined): string | undefined {
+  const structure = structuralIssue(entry);
+  if (structure || !entry) return structure;
+  if (
+    entry.type === "message" &&
+    "content" in entry.message &&
+    Array.isArray(entry.message.content) &&
+    entry.message.content.length > MESSAGE_BLOCKS
+  )
+    return "message content exceeds 2,048-block budget";
+  if (entry.type === "message" && entry.message.role === "system") {
+    // Native sessionEntryToContextMessages restores legacy missing/null content.
+    const m = entry.message;
+    const issue = systemMessageIssue(m.content == null ? { ...m, content: "" } : m);
+    if (issue) return issue;
+  }
+  if (entry.type === "compaction" && entry.systemMessage) {
+    const issue = systemMessageIssue(entry.systemMessage);
+    if (issue) return `checkpoint: ${issue}`;
+  }
+  if (
+    entry.type === "message" &&
+    entry.message.role === "assistant" &&
+    entry.message.content != null &&
+    (!Array.isArray(entry.message.content) ||
+      Array.from(entry.message.content).some((block) => !block || typeof block !== "object" || Array.isArray(block)))
+  )
+    return "malformed assistant content block or envelope";
+  if (
+    entry.type === "message" &&
+    entry.message.role === "assistant" &&
+    Array.isArray(entry.message.content) &&
+    entry.message.content.some(
+      (block) =>
+        block.type === "toolCall" &&
+        (!block.arguments ||
+          typeof block.arguments !== "object" ||
+          Array.isArray(block.arguments) ||
+          typeof block.id !== "string" ||
+          !block.id.length ||
+          block.id.length > 512 ||
+          typeof block.name !== "string" ||
+          !block.name.length ||
+          block.name.length > 512),
+    )
+  )
+    return "malformed tool-call envelope";
+  if (entry.type === "context_edit") {
+    if (typeof entry.targetId !== "string" || !entry.targetId.length || entry.targetId.length > 512)
+      return "malformed context-edit target id";
+    const value = entry.replacement;
+    if (Array.isArray(value?.content) && value.content.length > MESSAGE_BLOCKS)
+      return "context-edit content exceeds 2,048-block budget";
+    if (
+      value !== null &&
+      (!value ||
+        typeof value !== "object" ||
+        Array.isArray(value) ||
+        !("content" in value) ||
+        (typeof value.content !== "string" && !Array.isArray(value.content)) ||
+        (Array.isArray(value.content) &&
+          value.content.some((block) => !block || typeof block !== "object" || Array.isArray(block))))
+    )
+      return "malformed context-edit replacement";
+  }
+  if (
+    entry.type === "message" &&
+    entry.message.role === "toolResult" &&
+    (typeof entry.message.toolCallId !== "string" ||
+      !entry.message.toolCallId.length ||
+      entry.message.toolCallId.length > 512)
+  )
+    return "malformed or over-budget tool-result id";
+  return undefined;
+}
+
+export function recordedLeaf(
+  manager: ExtensionContext["sessionManager"],
+  duplicates?: ReadonlySet<string>,
+): string | null {
+  const leaf = manager.getLeafId();
+  return typeof leaf === "string" &&
+    leaf.length > 0 &&
+    leaf.length <= 512 &&
+    !duplicates?.has(leaf) &&
+    !identityIssue(manager.getEntry(leaf))
+    ? leaf
+    : null;
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { registerInspector as default } from "./extension.js";

package/src/model.ts

@@ -0,0 +1,117 @@
+export type Json = null | boolean | number | string | Json[] | { [key: string]: Json };
+export interface Capture {
+  value: Json;
+  truncated: boolean;
+}
+export interface EntrySummary {
+  id: string;
+  parentId: string | null;
+  kind: string;
+  label: string;
+  summary?: string;
+  summaryTruncated?: boolean;
+  internal?: true;
+  timestamp: string;
+  name?: string;
+  nameTruncated?: boolean;
+  tokens?: number;
+  status?: "success" | "error" | "cancelled";
+  toolCallId?: string;
+  toolAnchor?: string;
+}
+export interface Call {
+  id: string;
+  occurrenceId: string;
+  parentOccurrenceId?: string;
+  parentUnavailable?: string;
+  correlationUnavailable?: boolean;
+  parentId?: string;
+  name: string;
+  status: "running" | "ok" | "error" | "unfinished";
+  args: Capture;
+  result?: Capture;
+  durationMs?: number;
+  observedStartedAt?: number;
+  observedEndedAt?: number;
+  branchAnchor: string | null;
+}
+export interface ToolView {
+  name: string;
+  description: string;
+  exposure: string;
+  active: boolean;
+  callable: boolean;
+  namespace?: string;
+  schema: Capture;
+}
+export interface SkillView {
+  name: string;
+  path: string;
+  description: string;
+}
+export interface ContextSegment {
+  id: string;
+  position: number;
+  messageIndex: number;
+  blockIndex?: number;
+  role: string;
+  kind: string;
+  category: "system" | "user" | "assistant" | "toolCall" | "toolResult" | "other";
+  preview: string;
+  timestamp?: string;
+}
+export interface ContextComposition {
+  source: "observed-pi-context" | "session-derived";
+  leafId: string | null;
+  observedAt?: number;
+  totalMessages: number;
+  messages: Capture[];
+  segments: ContextSegment[];
+  incomplete: boolean;
+  unavailable?: string;
+}
+export interface Snapshot {
+  protocol: 1;
+  generation: string;
+  revision: number;
+  sessionId: string;
+  name: string;
+  nameTruncated?: boolean;
+  leafId: string | null;
+  totalEntries: number;
+  nodes: EntrySummary[];
+  incomplete: boolean;
+  invalidEntryCount?: number;
+  invalidEntries?: { index: number; reason: string; raw: Capture }[];
+  context?: ContextComposition;
+  providerObservation?: { observedAt: number; data: Capture };
+  currentPrompt: Capture;
+  tools: ToolView[];
+  skills: SkillView[];
+  calls: Call[];
+  droppedCalls: number;
+  invalidCallEvents?: number;
+  captureStartedAt: number;
+}
+export interface BranchView {
+  ancestryIssue?: string;
+  leafId: string;
+  entries: EntrySummary[];
+  total: number;
+  offset: number;
+  prompt: Capture;
+  previousPrompt: Capture;
+  sections: Capture;
+  declaredTools: Capture;
+  promptUpdates: Capture;
+  projection: Capture;
+  context?: ContextComposition;
+  skillEvidence: Capture;
+}
+export interface DetailView {
+  ancestryIssue?: string;
+  toolAnchor?: string;
+  raw: Capture;
+  projected: Capture;
+  calls: Call[];
+}

package/src/native-projection.ts

@@ -0,0 +1,28 @@
+import { buildContextEntries, buildSessionProjection, type SessionEntry } from "@earendil-works/pi-coding-agent";
+import { identityIssue } from "./identity.js";
+
+// Parent/role structure has already been validated. Native selection drops old
+// summaries/checkpoints and applies edits before content-envelope validation.
+export function nativeProjection(path: SessionEntry[], leaf: string | null) {
+  const contextEntries = buildContextEntries(path, leaf);
+  if (contextEntries[0]?.type === "compaction") {
+    const issue = identityIssue(contextEntries[0]);
+    if (issue) return { issue };
+  }
+  const edits = new Map(
+    contextEntries.filter((entry) => entry.type === "context_edit").map((entry) => [entry.targetId, entry]),
+  );
+  for (const entry of edits.values()) {
+    if (entry.type === "context_edit") {
+      const issue = identityIssue(entry);
+      if (issue) return { issue };
+    }
+  }
+  const projection = buildSessionProjection(path, leaf);
+  for (const projected of projection.entries)
+    for (const message of projected.messages) {
+      const issue = identityIssue({ ...projected.sourceEntry, type: "message", message } as SessionEntry);
+      if (issue) return { issue };
+    }
+  return { projection };
+}