@unifedev/thread-pages 0.3.2 → 1.0.3

package/src/pages/page-store.ts

@@ -0,0 +1,136 @@
+import { PageError, PUBLIC_MESSAGES, errorText } from "../domain/errors.ts";
+import { isRevision } from "../domain/ids.ts";
+import { LIMITS } from "../domain/limits.ts";
+import { revisionOf } from "../domain/revision.ts";
+import type { SessionHost } from "../host/contract.ts";
+import { ENTRY_FILE } from "./layout.ts";
+
+/**
+ * Loads a page's entry document, bounds it, computes its revision, and keeps
+ * a last-known-good copy so the page still opens read-only when its source
+ * host is unreachable. spec R1.7, R2.11, R2.27–R2.30
+ */
+export interface LoadedPage {
+  readonly html: string;
+  readonly revision: string;
+  readonly updatedAtMs: number;
+  /** True when served from the offline copy. */
+  readonly stale: boolean;
+}
+
+interface CachedPage {
+  readonly html: string;
+  readonly revision: string;
+  readonly updatedAtMs: number;
+}
+
+export interface PageStore {
+  load(session: string): Promise<LoadedPage>;
+  /** Records a document the plugin just wrote, so the next load is warm. */
+  remember(session: string, html: string): Promise<CachedPage>;
+  /** The revision last seen for a session, without touching the host. */
+  knownRevision(session: string): string | null;
+}
+
+const KV_PREFIX = "cache:";
+
+export function createPageStore(host: SessionHost): PageStore {
+  const memory = new Map<string, CachedPage>();
+  let memoryBytes = 0;
+
+  function cost(page: CachedPage): number {
+    return Buffer.byteLength(page.html, "utf8") + 128;
+  }
+
+  function retain(session: string, page: CachedPage): void {
+    const previous = memory.get(session);
+    if (previous) {
+      memoryBytes -= cost(previous);
+      memory.delete(session);
+    }
+    memory.set(session, page);
+    memoryBytes += cost(page);
+    while (memory.size > LIMITS.offlineCacheEntries || memoryBytes > LIMITS.offlineCacheBytes) {
+      const oldest = memory.keys().next().value;
+      if (oldest === undefined) break;
+      const evicted = memory.get(oldest);
+      memory.delete(oldest);
+      if (evicted) memoryBytes -= cost(evicted);
+    }
+  }
+
+  async function persist(session: string, page: CachedPage, previousRevision: string | undefined): Promise<void> {
+    if (previousRevision === page.revision) return;
+    const key = KV_PREFIX + session;
+    if (Buffer.byteLength(page.html, "utf8") > LIMITS.offlineCopyBytes) {
+      await host.kv.delete(key).catch((error: unknown) => host.log.warn(`offline copy: could not clear ${session}: ${errorText(error)}`));
+      return;
+    }
+    await host.kv.set(key, { html: page.html, revision: page.revision, updatedAtMs: page.updatedAtMs }).catch((error: unknown) => {
+      host.log.warn(`offline copy: could not store ${session}: ${errorText(error)}`);
+    });
+  }
+
+  async function cached(session: string): Promise<CachedPage | null> {
+    const resident = memory.get(session);
+    if (resident) return resident;
+    try {
+      const stored = await host.kv.get(KV_PREFIX + session);
+      if (!isCachedPage(stored)) return null;
+      retain(session, stored);
+      return stored;
+    } catch (error) {
+      host.log.warn(`offline copy: could not read ${session}: ${errorText(error)}`);
+      return null;
+    }
+  }
+
+  async function remember(session: string, html: string, updatedAtMs = Date.now()): Promise<CachedPage> {
+    const page: CachedPage = { html, revision: revisionOf(html), updatedAtMs };
+    const previous = memory.get(session)?.revision;
+    retain(session, page);
+    await persist(session, page, previous);
+    return page;
+  }
+
+  return {
+    async load(session) {
+      let content;
+      try {
+        const location = await host.sessions.storage(session);
+        content = await host.files.read(location, ENTRY_FILE);
+      } catch (error) {
+        const fallback = await cached(session);
+        if (fallback) return { ...fallback, stale: true };
+        throw PageError.is(error) ? error : new PageError("unavailable", PUBLIC_MESSAGES.unavailable, { cause: error });
+      }
+      if (!content) throw new PageError("no_page", PUBLIC_MESSAGES.noPage);
+      if (content.bytes.byteLength > LIMITS.entryDocumentBytes) {
+        throw new PageError("page_too_large", PUBLIC_MESSAGES.pageTooLarge);
+      }
+      const html = Buffer.from(content.bytes).toString("utf8");
+      const page: CachedPage = { html, revision: revisionOf(content.bytes), updatedAtMs: content.modifiedAtMs ?? Date.now() };
+      const previous = memory.get(session)?.revision;
+      retain(session, page);
+      await persist(session, page, previous);
+      return { ...page, stale: false };
+    },
+    remember,
+    knownRevision(session) {
+      return memory.get(session)?.revision ?? null;
+    },
+  };
+}
+
+function isCachedPage(value: unknown): value is CachedPage {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const entry = value as Record<string, unknown>;
+  return (
+    typeof entry.html === "string" &&
+    Buffer.byteLength(entry.html, "utf8") <= LIMITS.offlineCopyBytes &&
+    isRevision(entry.revision) &&
+    revisionOf(entry.html) === entry.revision &&
+    typeof entry.updatedAtMs === "number" &&
+    Number.isFinite(entry.updatedAtMs)
+  );
+}

package/src/pages/site.ts

@@ -0,0 +1,36 @@
+/**
+ * How a page's site reaches the reader. spec R1.2, R1.3; rewrite RW-1
+ *
+ * The document is always served by this plugin (it needs the kernel). Where
+ * its files come from depends on what the host's router can do:
+ *
+ * - `core-storage`: the host already serves the session's storage as a site
+ *   at a stable path; the document gets one same-origin `<base>` so relative
+ *   references resolve there. This is what bb 0.42.1 allows.
+ * - `plugin-prefix`: the plugin serves `/page/<id>/…` itself; the document
+ *   URL is path-shaped and no base is needed. Available once the host's
+ *   plugin router matches prefixes.
+ */
+export interface SiteStrategy {
+  readonly name: "core-storage" | "plugin-prefix";
+  /** Origin-relative URL the shell loads into the iframe. */
+  documentUrl(session: string): string;
+  /** Same-origin `<base href>` to inject, or null when the document URL is path-shaped. */
+  baseHref(session: string): string | null;
+}
+
+export function createCoreStorageSite(routeBase: string, storageFilesBase: (session: string) => string): SiteStrategy {
+  return {
+    name: "core-storage",
+    documentUrl: (session) => `${routeBase}/document?session=${encodeURIComponent(session)}`,
+    baseHref: (session) => storageFilesBase(session),
+  };
+}
+
+export function createPluginPrefixSite(routeBase: string): SiteStrategy {
+  return {
+    name: "plugin-prefix",
+    documentUrl: (session) => `${routeBase}/page/${encodeURIComponent(session)}/`,
+    baseHref: () => null,
+  };
+}

package/src/plugin.ts

@@ -0,0 +1,71 @@
+import type { BbPluginApi } from "@get-bb/plugin-sdk";
+import { registerCli } from "./agent/cli.ts";
+import { buildGuide } from "./agent/guide.ts";
+import { createBbHost } from "./bb/bb-host.ts";
+import { defineSettings } from "./config/settings.ts";
+import { capabilityRegistry } from "./domain/capabilities/index.ts";
+import { createRateLimiter } from "./domain/rate-limit.ts";
+import { createOutcomeMemory } from "./domain/submissions/idempotency.ts";
+import type { SessionHost } from "./host/contract.ts";
+import { createPageStore } from "./pages/page-store.ts";
+import { createCoreStorageSite, type SiteStrategy } from "./pages/site.ts";
+import { createSelectionStore } from "./serving/bridge/selection-store.ts";
+import type { ServingContext } from "./serving/context.ts";
+import { registerRoutes } from "./serving/routes.ts";
+import { loadSigningKey } from "./serving/signing-key.ts";
+
+/**
+ * The composition root: the only file that knows every package. Builds the
+ * host adapter, the stores and the serving context, then registers routes,
+ * the CLI and the agent-instruction hook.
+ */
+export interface PluginOptions {
+  /** Override the host (tests). */
+  host?: SessionHost;
+  /** Override the site strategy (tests, or a host with prefix routes). */
+  site?: (routeBase: string) => SiteStrategy;
+  now?: () => number;
+}
+
+export async function createPlugin(bb: BbPluginApi, options: PluginOptions = {}): Promise<ServingContext> {
+  const settings = await defineSettings(bb);
+  const host = options.host ?? createBbHost(bb);
+  const signingKey = await loadSigningKey(host);
+  const routeBase = `/api/v1/plugins/${bb.pluginId}/http`;
+  const site = options.site
+    ? options.site(routeBase)
+    : createCoreStorageSite(routeBase, (session) => `/api/v1/threads/${encodeURIComponent(session)}/thread-storage/files/`);
+
+  const serving: ServingContext = {
+    host,
+    pages: createPageStore(host),
+    settings,
+    signingKey,
+    site,
+    routeBase,
+    registry: capabilityRegistry,
+    rate: createRateLimiter(),
+    submissions: createOutcomeMemory(),
+    replies: createOutcomeMemory(),
+    selections: createSelectionStore(),
+    hostSessionUrl: (session) => `/threads/${encodeURIComponent(session)}`,
+    now: options.now ?? (() => Date.now()),
+  };
+
+  const effectiveInstruction = (): string | null => {
+    const current = settings.current();
+    return current.agentInstructions && current.agentInstructionText.trim() ? current.agentInstructionText : null;
+  };
+
+  // The standing instruction: only eligible sessions, only when enabled.
+  // Visibility is not known here, so `init` rechecks eligibility at call time. spec R6.14
+  bb.agents.configure((context) => {
+    const instruction = effectiveInstruction();
+    const root = context.thread.parentThreadId === null && context.thread.sourceThreadId === null && context.origin.kind === null;
+    return instruction && root ? { tools: [], skills: [], instructions: instruction } : { tools: [], skills: [] };
+  });
+
+  registerRoutes(bb, serving);
+  registerCli(bb, { serving, guide: buildGuide(capabilityRegistry, site), effectiveInstruction });
+  return serving;
+}

package/src/runtime/kernel/anchors.ts

@@ -0,0 +1,45 @@
+/**
+ * Authored links work. spec R4.15
+ *
+ * The sandbox has no top-level navigation, so an `<a href>` to another site
+ * would silently do nothing (or replace the page inside the frame). The
+ * kernel routes http(s) destinations through `navigation.openExternal`,
+ * leaves same-document fragments and the page's own files to the browser,
+ * and swallows schemes the sandbox cannot honour.
+ */
+export type AnchorDecision = { kind: "default" } | { kind: "external"; url: string; label: string } | { kind: "block" };
+
+export function decideAnchor(anchor: HTMLAnchorElement, documentUrl: string, siteBase: string | null): AnchorDecision {
+  const raw = anchor.getAttribute("href");
+  if (raw === null) return { kind: "default" };
+  if (raw.startsWith("#")) return { kind: "default" };
+  let target: URL;
+  try {
+    target = new URL(raw, siteBase ?? documentUrl);
+  } catch {
+    return { kind: "block" };
+  }
+  if (target.protocol !== "http:" && target.protocol !== "https:") return { kind: "block" };
+  if (siteBase && target.href.startsWith(siteBase)) return { kind: "default" };
+  if (anchor.hasAttribute("download")) return { kind: "default" };
+  return { kind: "external", url: target.href, label: (anchor.textContent || "").replace(/\s+/g, " ").trim().slice(0, 160) };
+}
+
+export function installAnchorInterception(doc: Document, open: (url: string, label: string) => void): void {
+  doc.addEventListener(
+    "click",
+    (event) => {
+      if (event.defaultPrevented || event.button !== 0) return;
+      const target = event.target as Element | null;
+      const anchor = target?.closest?.("a[href]") as HTMLAnchorElement | null;
+      if (!anchor) return;
+      const base = doc.querySelector("base")?.getAttribute("href") ?? null;
+      const siteBase = base ? new URL(base, doc.baseURI).href : null;
+      const decision = decideAnchor(anchor, doc.baseURI, siteBase);
+      if (decision.kind === "default") return;
+      event.preventDefault();
+      if (decision.kind === "external") open(decision.url, decision.label);
+    },
+    true,
+  );
+}

package/src/runtime/kernel/api.ts

@@ -0,0 +1,15 @@
+/**
+ * `window.threadPage`: the complete page-facing API, frozen, non-writable and
+ * non-configurable so one script cannot shim it for another. spec R4.3, R4.28–R4.33
+ */
+export interface ThreadPageApi {
+  readonly version: 1;
+  invoke(method: string, params?: unknown): Promise<unknown>;
+  watch(method: string, params: unknown, listener: (value: unknown, error: unknown) => void, options?: { intervalMs?: number }): () => void;
+  setDirty(dirty: boolean): void;
+}
+
+export function installApi(target: Window, api: ThreadPageApi): void {
+  const frozen = Object.freeze({ version: 1 as const, invoke: api.invoke, watch: api.watch, setDirty: api.setDirty });
+  Object.defineProperty(target, "threadPage", { value: frozen, writable: false, configurable: false, enumerable: true });
+}

package/src/runtime/kernel/bridge-client.ts

@@ -0,0 +1,148 @@
+import { LIMITS } from "../../domain/limits.ts";
+import { BRIDGE_VERSION, isBridgeResponse, type BridgeRequestMessage, type BridgeResponseMessage } from "../shared/protocol.ts";
+import type { BridgeErrorCode } from "../../domain/errors.ts";
+
+/**
+ * `invoke` and `watch` as a page sees them. Calls made before the port is
+ * ready are queued; every response is checked before it is trusted; a
+ * failure rejects with an Error carrying a `code`. spec R4.28–R4.32
+ */
+export interface BridgeClient {
+  invoke(method: string, params?: unknown): Promise<unknown>;
+  watch(method: string, params: unknown, listener: (value: unknown, error: unknown) => void, options?: { intervalMs?: number }): () => void;
+  /** Called by the kernel once the shell hands over the port. */
+  attach(post: (message: BridgeRequestMessage) => void): void;
+  /** Called by the kernel for every port message; returns true when consumed. */
+  receive(message: unknown): boolean;
+}
+
+export class ThreadPageError extends Error {
+  readonly code: BridgeErrorCode;
+  constructor(code: BridgeErrorCode, message: string) {
+    super(message);
+    this.name = "ThreadPageError";
+    this.code = code;
+    Object.defineProperty(this, "code", { value: code, enumerable: true, writable: false });
+  }
+}
+
+interface Pending {
+  request: BridgeRequestMessage;
+  resolve: (value: unknown) => void;
+  reject: (error: Error) => void;
+}
+
+export function createBridgeClient(pageRevision: string, doc: Document): BridgeClient {
+  const pending = new Map<string, Pending>();
+  const queued: string[] = [];
+  let post: ((message: BridgeRequestMessage) => void) | null = null;
+  let sequence = 0;
+
+  function nextId(): string {
+    sequence += 1;
+    const random = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `${Date.now()}-${sequence}`;
+    return `tp-${random}`;
+  }
+
+  function send(id: string): void {
+    const entry = pending.get(id);
+    if (!entry || !post) return;
+    try {
+      post(entry.request);
+    } catch (error) {
+      pending.delete(id);
+      entry.reject(new ThreadPageError("invalid_request", error instanceof Error ? error.message : "The request could not be sent"));
+    }
+  }
+
+  function invoke(method: string, params?: unknown): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+      if (typeof method !== "string") {
+        reject(new ThreadPageError("invalid_request", "A method name is required"));
+        return;
+      }
+      const id = nextId();
+      const request: BridgeRequestMessage = { v: BRIDGE_VERSION, id, method, params: params === undefined ? null : params, pageRevision };
+      pending.set(id, { request, resolve, reject });
+      if (post) send(id);
+      else queued.push(id);
+    });
+  }
+
+  function watch(method: string, params: unknown, listener: (value: unknown, error: unknown) => void, options?: { intervalMs?: number }): () => void {
+    if (typeof listener !== "function") throw new TypeError("Thread Page watch needs a listener");
+    const requested = options?.intervalMs;
+    const interval = typeof requested === "number" && Number.isFinite(requested)
+      ? Math.max(LIMITS.watchMinMs, Math.min(LIMITS.watchMaxMs, Math.round(requested)))
+      : LIMITS.watchDefaultMs;
+    let stopped = false;
+    let running = false;
+    let timer: ReturnType<typeof setTimeout> | null = null;
+
+    function schedule(delay: number): void {
+      if (stopped) return;
+      if (timer !== null) clearTimeout(timer);
+      timer = setTimeout(tick, delay);
+    }
+    async function tick(): Promise<void> {
+      timer = null;
+      if (stopped || running || doc.visibilityState === "hidden") return;
+      running = true;
+      try {
+        const value = await invoke(method, params);
+        if (!stopped) listener(value, null);
+      } catch (error) {
+        if (!stopped) listener(undefined, error);
+      } finally {
+        running = false;
+        if (!stopped) schedule(interval);
+      }
+    }
+    function onVisibility(): void {
+      if (stopped) return;
+      if (doc.visibilityState === "hidden") {
+        if (timer !== null) clearTimeout(timer);
+        timer = null;
+      } else {
+        schedule(0);
+      }
+    }
+    doc.addEventListener("visibilitychange", onVisibility);
+    schedule(0);
+    return () => {
+      if (stopped) return;
+      stopped = true;
+      if (timer !== null) clearTimeout(timer);
+      timer = null;
+      doc.removeEventListener("visibilitychange", onVisibility);
+    };
+  }
+
+  return {
+    invoke,
+    watch,
+    attach(poster) {
+      post = poster;
+      while (queued.length > 0) {
+        const id = queued.shift();
+        if (id) send(id);
+      }
+    },
+    receive(message) {
+      if (typeof message !== "object" || message === null) return false;
+      const id = (message as { id?: unknown }).id;
+      if (typeof id !== "string") return false;
+      const entry = pending.get(id);
+      if (!entry) return false;
+      pending.delete(id);
+      if (!isBridgeResponse(message, id)) {
+        entry.reject(new ThreadPageError("invalid_response", "The Thread Page bridge returned an invalid response"));
+        return true;
+      }
+      const response = message as BridgeResponseMessage;
+      if (response.ok) entry.resolve(response.result);
+      else entry.reject(new ThreadPageError(response.error.code, response.error.message));
+      return true;
+    },
+  };
+}

package/src/runtime/kernel/dirty.ts

@@ -0,0 +1,51 @@
+/**
+ * The dirty flag: typing into a captured form, or a page's explicit
+ * `setDirty(true)`, tells the shell not to reload under the reader.
+ * spec R2.21–R2.23
+ */
+export interface DirtyTracker {
+  /** Current combined state. */
+  isDirty(): boolean;
+  /** Marks a form dirty; returns the version recorded for it. */
+  markForm(form: HTMLFormElement): number;
+  /** The version a form was last marked with, if any. */
+  versionOf(form: HTMLFormElement): number | undefined;
+  /** Clears a form's dirt only if nothing touched it since `version`. */
+  clearForm(form: HTMLFormElement, version: number | undefined): void;
+  setCustom(dirty: boolean): void;
+}
+
+export function createDirtyTracker(onChange: (dirty: boolean) => void): DirtyTracker {
+  const versions = new Map<HTMLFormElement, number>();
+  let sequence = 0;
+  let custom = false;
+  let last = false;
+
+  function sync(): void {
+    const next = custom || versions.size > 0;
+    if (next === last) return;
+    last = next;
+    onChange(next);
+  }
+
+  return {
+    isDirty: () => last,
+    markForm(form) {
+      sequence += 1;
+      versions.set(form, sequence);
+      sync();
+      return sequence;
+    },
+    versionOf: (form) => versions.get(form),
+    clearForm(form, version) {
+      if (version !== undefined && versions.get(form) === version) {
+        versions.delete(form);
+        sync();
+      }
+    },
+    setCustom(dirty) {
+      custom = dirty === true;
+      sync();
+    },
+  };
+}

package/src/runtime/kernel/forms.ts

@@ -0,0 +1,114 @@
+import { LIMITS } from "../../domain/limits.ts";
+import type { SubmitFile } from "../shared/protocol.ts";
+import { collectAnswers } from "./labels.ts";
+
+/**
+ * Automatic form capture. spec R4.5–R4.9
+ *
+ * Every `<form>` without `data-thread-page-manual` is captured: native
+ * validation is suppressed (blank is an answer), a status line is kept per
+ * form, ranges get a live readout, and while a submission is in flight the
+ * form's controls are disabled and restored afterwards.
+ */
+export const MANUAL_ATTRIBUTE = "data-thread-page-manual";
+export const STATUS_ATTRIBUTE = "data-thread-page-status";
+const RANGE_ATTRIBUTE = "data-thread-page-range";
+
+export interface SubmitIntent {
+  submissionId: string;
+  form: HTMLFormElement;
+  title: string;
+  answers: ReturnType<typeof collectAnswers>;
+  files: SubmitFile[];
+}
+
+export function isManualForm(form: Element): boolean {
+  return form.hasAttribute(MANUAL_ATTRIBUTE);
+}
+
+export function capturedForms(root: ParentNode | Element): HTMLFormElement[] {
+  const forms: HTMLFormElement[] = [];
+  if ("tagName" in root && (root as Element).tagName.toLowerCase() === "form") forms.push(root as HTMLFormElement);
+  if ("querySelectorAll" in root) forms.push(...Array.from(root.querySelectorAll("form")));
+  return forms.filter((form) => !isManualForm(form));
+}
+
+export function statusLine(form: HTMLFormElement): HTMLElement {
+  let node = form.querySelector<HTMLElement>(`[${STATUS_ATTRIBUTE}]`);
+  if (!node) {
+    node = form.ownerDocument.createElement("p");
+    node.setAttribute(STATUS_ATTRIBUTE, "");
+    node.setAttribute("role", "status");
+    form.appendChild(node);
+  }
+  return node;
+}
+
+const preparedRanges = new WeakSet<HTMLInputElement>();
+
+export function prepareForm(form: HTMLFormElement): void {
+  form.noValidate = true;
+  for (const input of Array.from(form.querySelectorAll<HTMLInputElement>('input[type="range"]'))) {
+    if (preparedRanges.has(input)) continue;
+    preparedRanges.add(input);
+    const output = form.ownerDocument.createElement("output");
+    output.setAttribute(RANGE_ATTRIBUTE, "");
+    const sync = () => {
+      output.textContent = String(input.value);
+    };
+    input.addEventListener("input", sync);
+    sync();
+    input.insertAdjacentElement("afterend", output);
+  }
+}
+
+export type FormControl = HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | HTMLButtonElement | HTMLFieldSetElement;
+
+export function controlsOf(form: HTMLFormElement): FormControl[] {
+  return Array.from(form.querySelectorAll<FormControl>("input,textarea,select,button,fieldset"));
+}
+
+export function filesOf(form: HTMLFormElement): SubmitFile[] {
+  const out: SubmitFile[] = [];
+  for (const input of Array.from(form.querySelectorAll<HTMLInputElement>('input[type="file"]'))) {
+    if (input.disabled) continue;
+    for (const file of Array.from(input.files ?? [])) {
+      if (out.length >= LIMITS.uploadsPerForm) return out;
+      out.push({ field: input.name || "file", file });
+    }
+  }
+  return out;
+}
+
+export interface PendingForm {
+  form: HTMLFormElement;
+  disabled: FormControl[];
+  dirtyVersion: number | undefined;
+}
+
+/** Disables the controls that were enabled, remembering them for restore. spec R4.8 */
+export function lockForm(form: HTMLFormElement): FormControl[] {
+  const disabled: FormControl[] = [];
+  for (const control of controlsOf(form)) {
+    if (!control.disabled) {
+      control.disabled = true;
+      disabled.push(control);
+    }
+  }
+  return disabled;
+}
+
+export function unlockForm(disabled: FormControl[]): void {
+  for (const control of disabled) control.disabled = false;
+}
+
+export function titleOf(form: HTMLFormElement): string {
+  const explicit = form.getAttribute("data-title");
+  if (explicit && explicit.trim()) return explicit.trim().slice(0, 300);
+  const heading = form.ownerDocument.querySelector("h1");
+  return (heading?.textContent || "").trim().slice(0, 300) || "Thread Page";
+}
+
+export function buildIntent(form: HTMLFormElement, submitter: HTMLElement | null, submissionId: string): SubmitIntent {
+  return { submissionId, form, title: titleOf(form), answers: collectAnswers(form, submitter), files: filesOf(form) };
+}