@botiverse/porthole 0.1.2 → 0.1.4

package/src/config/capabilities.ts

@@ -1,3 +1,5 @@
+import type { AnnotationReport } from "../annotate/types.ts";
+
 /**
  * The capability vocabulary (PRINCIPLE 4): every power content has beyond drawing is one of these
  * host functions, named in the config. A capability the config doesn't declare is not wired into
@@ -17,6 +19,8 @@ export const CAPABILITY_NAMES = [
   "setModelContext",
   "reportError",
   "resize",
+  "copyText",
+  "annotate",
 ] as const;
 
 export type CapabilityName = (typeof CAPABILITY_NAMES)[number];
@@ -44,14 +48,18 @@ export interface CapabilitySpec {
   /** The global the shell defines for it (sugar over the protocol message), if any. */
   readonly global?: string;
   /**
-   * How content reaches it without the shell's global: the MCP Apps request, and the official
-   * App SDK's method for it. Absent for what the shell does by itself (sizes, errors).
+   * How content reaches it without the shell's global: the MCP Apps request (or Porthole's own,
+   * `porthole/…`, where the standard has none), and the official App SDK's method for it, if any.
+   * Absent for what the shell does by itself (sizes, errors, annotations).
    */
-  readonly request?: { readonly method: string; readonly sdk: string };
+  readonly request?: { readonly method: string; readonly sdk?: string };
 }
 
 const rate = (perMinute: number): Gate => ({ rateLimit: { perMinute } });
 
+/** The most text one `copyText` call carries. */
+export const MAX_COPY_CHARS = 20_000;
+
 export const CAPABILITIES = {
   sendPrompt: {
     defaultGates: ["user-activation", "confirm"],
@@ -87,6 +95,22 @@ export const CAPABILITIES = {
   },
   reportError: { defaultGates: [rate(10)], served: "event" },
   resize: { defaultGates: [], served: "event" },
+  /**
+   * Copies text to the person's clipboard, done by the host, which shows them what was copied
+   * (P052). Content can't write the clipboard any other way (P051).
+   */
+  copyText: {
+    defaultGates: ["user-activation", rate(30)],
+    served: "handler",
+    global: "copyText",
+    request: { method: "porthole/copy-text" },
+  },
+  /**
+   * Annotations (P053): the host asks the shell to let the person point at an element or select
+   * text, and to mark anchors already made. What the frame reports back is the content's word
+   * (it shares the realm): UI hints for the host, never permissions.
+   */
+  annotate: { defaultGates: [rate(120)], served: "event" },
 } as const satisfies { readonly [N in CapabilityName]: CapabilitySpec };
 
 /** The arguments a call carries, once the adapter has validated them. */
@@ -106,6 +130,9 @@ export interface CapabilityArgs {
   };
   readonly reportError: { readonly message: string };
   readonly resize: { readonly height: number; readonly width?: number };
+  readonly copyText: { readonly text: string };
+  /** What the frame reported, once checked (`AnnotationReport`). */
+  readonly annotate: AnnotationReport;
 }
 
 /** What a call resolves to. Protocol-shaped results (a tool's result) stay opaque to the core. */
@@ -121,6 +148,9 @@ export interface CapabilityResults {
   readonly setModelContext: undefined;
   readonly reportError: undefined;
   readonly resize: undefined;
+  /** Whether the text was copied. */
+  readonly copyText: boolean;
+  readonly annotate: undefined;
 }
 
 /** The capabilities a host serves with a handler. */

package/src/config/schema.ts

@@ -175,4 +175,16 @@ export interface PortholeConfig {
   readonly sandbox?: readonly UrlSandboxExtra[];
   /** Url mode only: features delegated to the frame (`URL_PERMISSIONS`); none by default. */
   readonly permissions?: readonly UrlPermission[];
+  /**
+   * Domain isolation: how far a display's storage reaches, for the manual. Storage is per origin,
+   * and the host picks each display's origin (`InstanceRef.scope`); a host that gives several
+   * displays one scope (all of a conversation's widgets) names it here (`{ shared:
+   * "conversation" }`), so the manual says storage is shared across it and keys need a prefix.
+   */
+  readonly storage?: StorageConfig;
+}
+
+export interface StorageConfig {
+  /** What the displays sharing one origin have in common, as a noun ("conversation"). */
+  readonly shared?: string;
 }

package/src/config/validate.ts

@@ -131,6 +131,7 @@ export function validateConfig(input: unknown): PortholeConfig {
       "embedder",
       "sandbox",
       "permissions",
+      "storage",
     ],
     "config",
   );
@@ -315,6 +316,20 @@ export function validateConfig(input: unknown): PortholeConfig {
     });
   }
 
+  if (config.storage !== undefined) {
+    const storage = object(config.storage, "config.storage");
+    only(storage, ["shared"], "config.storage");
+    if (config.isolation !== "domain") {
+      fail("config.storage", "only domain isolation keeps storage across displays");
+    }
+    if (
+      storage.shared !== undefined &&
+      (typeof storage.shared !== "string" || !/^[a-z][a-z -]{0,39}$/u.test(storage.shared))
+    ) {
+      fail("config.storage.shared", 'must be a short lowercase noun ("conversation")');
+    }
+  }
+
   if (config.permissions !== undefined) {
     if (config.mode !== "url") {
       fail("config.permissions", "only url mode may be delegated features");

package/src/conformance/clipboard.ts

@@ -0,0 +1,184 @@
+import { expect, type Page } from "@playwright/test";
+import type { LaunchedDisplay } from "./index.ts";
+import { inline, type Probe } from "./kit.ts";
+import { settle } from "./oracles.ts";
+
+/**
+ * The clipboard (item 13, P051): content can't write it, whatever it tries in a person's click,
+ * and what a person copies themselves is what they selected. `copyText` is the way copy buttons
+ * work instead (item 12, P052). The oracle is the person's own clipboard: known text put on it
+ * from the host's page, then pasted back into a text area there.
+ */
+
+const SEED = "porthole-seed";
+
+/** A text area of the oracle's own on the host's page. */
+async function area(page: Page, id: string): Promise<void> {
+  await page.evaluate((each) => {
+    if (document.getElementById(each) === null) {
+      const element = document.createElement("textarea");
+      element.id = each;
+      element.style.cssText = "display:block;width:200px;height:40px";
+      document.body.prepend(element);
+    }
+  }, id);
+}
+
+/** Puts `text` on the clipboard the way a person does: selects it on the host's page, copies. */
+async function seed(page: Page, text: string): Promise<void> {
+  await area(page, "porthole-oracle-seed");
+  await page.evaluate((each) => {
+    (document.getElementById("porthole-oracle-seed") as HTMLTextAreaElement).value = each;
+  }, text);
+  await page.locator("#porthole-oracle-seed").click();
+  await page.keyboard.press("ControlOrMeta+A");
+  await page.keyboard.press("ControlOrMeta+C");
+}
+
+/** What is on the clipboard: pasted into a text area on the host's page. */
+async function pasted(page: Page): Promise<string> {
+  await area(page, "porthole-oracle-paste");
+  await page.evaluate(() => {
+    (document.getElementById("porthole-oracle-paste") as HTMLTextAreaElement).value = "";
+  });
+  await page.locator("#porthole-oracle-paste").click();
+  await page.keyboard.press("ControlOrMeta+V");
+  await settle(200);
+  return page.evaluate(
+    () => (document.getElementById("porthole-oracle-paste") as HTMLTextAreaElement).value,
+  );
+}
+
+/** Clicks `selector` in the display (a real click: the user activation a person gives). */
+async function click(display: LaunchedDisplay, selector: string): Promise<void> {
+  await (await display.frame()).locator(selector).click();
+}
+
+async function bodyData(display: LaunchedDisplay, name: string): Promise<string> {
+  const frame = await display.frame();
+  await expect
+    .poll(() => frame.locator("body").getAttribute(`data-${name}`), { timeout: 5_000 })
+    .not.toBeNull();
+  return (await frame.locator("body").getAttribute(`data-${name}`)) ?? "";
+}
+
+const settled = (name: string) =>
+  `(value) => (document.body.dataset.${name} = String(value)), (error) => (document.body.dataset.${name} = "refused: " + (error && error.name))`;
+
+export const CLIPBOARD_PROBES: readonly Probe[] = [
+  {
+    id: "13.clipboard-api",
+    item: 13,
+    title:
+      "content can't write (or read) the clipboard through the async Clipboard API, even in a click",
+    async run(context) {
+      const display = await context.launch({
+        config: inline(),
+        content: `<button id="go">copy</button>
+<script>
+  document.getElementById("go").addEventListener("click", () => {
+    navigator.clipboard.writeText("porthole-pwned-text").then(${settled("text")});
+    if (typeof ClipboardItem === "function") {
+      navigator.clipboard.write([new ClipboardItem({ "text/plain": new Blob(["porthole-pwned-item"], { type: "text/plain" }) })]).then(${settled("item")});
+    } else {
+      document.body.dataset.item = "refused: no ClipboardItem";
+    }
+    navigator.clipboard.readText().then(${settled("read")});
+  });
+</script>`,
+      });
+      await seed(context.page, SEED);
+      await click(display, "#go");
+      expect(await bodyData(display, "text")).toMatch(/^refused/u);
+      expect(await bodyData(display, "item")).toMatch(/^refused/u);
+      expect(await bodyData(display, "read")).toMatch(/^refused/u);
+      expect(await pasted(context.page), "the clipboard still holds the person's own").toBe(SEED);
+    },
+  },
+  {
+    id: "13.clipboard-command",
+    item: 13,
+    title:
+      "content can't copy or cut its own text onto the clipboard with execCommand, even in a click",
+    async run(context) {
+      const display = await context.launch({
+        config: inline(),
+        content: `<button id="go">copy</button>
+<script>
+  document.getElementById("go").addEventListener("click", () => {
+    const area = document.createElement("textarea");
+    area.value = "porthole-pwned-command";
+    area.style.cssText = "position:absolute;left:-9999px";
+    document.body.append(area);
+    area.select();
+    let copied = "threw";
+    let cut = "threw";
+    try { copied = document.execCommand("copy"); } catch (_) {}
+    area.select();
+    try { cut = document.execCommand("cut"); } catch (_) {}
+    document.body.dataset.copied = String(copied) + "," + String(cut);
+  });
+</script>`,
+      });
+      await seed(context.page, SEED);
+      await click(display, "#go");
+      expect(await bodyData(display, "copied")).not.toContain("true");
+      expect(await pasted(context.page), "the clipboard still holds the person's own").toBe(SEED);
+    },
+  },
+  {
+    id: "13.clipboard-event",
+    item: 13,
+    title:
+      "what a person copies is what they selected: no copy listener of the content's can swap it",
+    async run(context) {
+      const display = await context.launch({
+        config: inline(),
+        content: `<p id="safe">porthole-selected-text</p>
+<script>
+  const swap = (event) => {
+    event.clipboardData.setData("text/plain", "porthole-pwned-event");
+    event.preventDefault();
+    document.body.dataset.ran = "yes";
+  };
+  document.addEventListener("copy", swap);
+  document.addEventListener("copy", swap, true);
+  window.addEventListener("copy", swap);
+  document.getElementById("safe").oncopy = swap;
+</script>`,
+      });
+      await seed(context.page, SEED);
+      const frame = await display.frame();
+      await frame.locator("#safe").click({ clickCount: 3 });
+      await context.page.keyboard.press("ControlOrMeta+C");
+      await settle(200);
+      // The positive control: the person's own copy works, and copies what they selected.
+      expect((await pasted(context.page)).trim()).toBe("porthole-selected-text");
+      expect(await frame.locator("body").getAttribute("data-ran")).toBeNull();
+    },
+  },
+  {
+    id: "12.copy-text",
+    item: 12,
+    title:
+      "copyText reaches the host's handler from a click, with the whole text, never without one",
+    async run(context) {
+      const display = await context.launch({
+        config: inline({ capabilities: { copyText: {} } }),
+        content: `<button id="copy">Copy the command</button>
+<script>
+  document.getElementById("copy").addEventListener("click", () => {
+    copyText("npm test -- --run").then(${settled("result")});
+  });
+  copyText("copied on load").then(${settled("onload")});
+</script>`,
+      });
+      expect(await bodyData(display, "onload")).toMatch(/^refused/u);
+      await click(display, "#copy");
+      expect(await bodyData(display, "result")).toBe("true");
+      expect(await display.calls()).toEqual([
+        { capability: "copyText", args: { text: "npm test -- --run" } },
+      ]);
+    },
+  },
+];

package/src/conformance/kit.ts

@@ -29,7 +29,7 @@ export interface Probe {
   readonly id: string;
   /**
    * The DESIGN.md egress-table item it proves; 0 for the shell's own wiring and interop, 11 for
-   * behavior (streaming, sizing, theming), 12 for host-function gates.
+   * behavior (streaming, sizing, theming), 12 for host-function gates, 13 for the clipboard.
    */
   readonly item: number;
   readonly title: string;

package/src/conformance/probes.ts

@@ -13,6 +13,7 @@ import { resolveTheme } from "../theme/variables.ts";
 import type { ConformanceHost, LaunchedDisplay, LeakSuiteOptions } from "./index.ts";
 import { attack, inline, js, type Probe, type ProbeContext } from "./kit.ts";
 import { BEHAVIOR_PROBES } from "./behavior.ts";
+import { CLIPBOARD_PROBES } from "./clipboard.ts";
 import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import {
@@ -1025,6 +1026,7 @@ export const PROBES: readonly Probe[] = [
     },
   },
   ...BEHAVIOR_PROBES,
+  ...CLIPBOARD_PROBES,
 ];
 
 type AnyTest = TestType<

package/src/conformance/served.ts

@@ -38,8 +38,17 @@ export interface ServedConformanceHost {
    * Shows `instance` in `page` as the host does: a fresh ticket from its backend, framed under
    * the config's sandbox, in an embedding page that sends the config's `embedderCsp`. The same page
    * may show several, one after another.
+   *
+   * For a served shell the suite gives `options.content`, a line of HTML: a host that speaks to
+   * the shell (`createHost`, the React binding) sends it as the display's content, since a shell
+   * draws nothing (and reports no height) until it has content, and the cases click inside it. A
+   * host whose frame has a height of its own may ignore it.
    */
-  show(page: Page, instance: InstanceRef): Promise<ServedDisplay>;
+  show(
+    page: Page,
+    instance: InstanceRef,
+    options?: { readonly content?: string },
+  ): Promise<ServedDisplay>;
   /** A fresh ticketed location for `instance`, as the host's backend issues it. */
   locate(instance: InstanceRef): Promise<FrameLocation>;
   /** Navigates `page` to a page on an origin that is not one of the host's, framing `url`. */
@@ -74,6 +83,9 @@ type Fixtures = { page: Page; browserName: string };
 
 const SETTLE_MS = 800;
 
+/** What a served shell is given to draw (`ServedConformanceHost.show`'s `content`). */
+const SHELL_CONTENT = '<p id="porthole-probe-content">Porthole conformance probe</p>';
+
 /** What the frame can see of its host: everything here must be closed to it. */
 async function reachIntoHost(frame: Frame): Promise<Record<string, string>> {
   return frame.evaluate(() => {
@@ -185,13 +197,16 @@ export function servedTests(
       ["domain", (scope: string) => host.shell(scope)],
       ["url", (scope: string) => host.app(scope)],
     ] as const;
+    // A served shell draws (and has a height to click in) once its host gives it content.
+    const showMode = (page: Page, mode: "domain" | "url", instance: InstanceRef) =>
+      host.show(page, instance, mode === "domain" ? { content: SHELL_CONTENT } : {});
 
     for (const [mode, instance] of modes) {
       define(
         `served.${mode}.origin`,
         "content runs on its own origin, never the host's",
         async ({ page }) => {
-          const display = await host.show(page, instance(`${mode}-origin`));
+          const display = await showMode(page, mode, instance(`${mode}-origin`));
           const frame = await display.frame();
           const origin = await frame.evaluate(() => window.origin);
           expect(origin).toBe(display.origin);
@@ -203,7 +218,7 @@ export function servedTests(
         `served.${mode}.no-reach`,
         "content can't reach the host's DOM, storage, cookies or URL",
         async ({ page }) => {
-          const display = await host.show(page, instance(`${mode}-reach`));
+          const display = await showMode(page, mode, instance(`${mode}-reach`));
           await plantHostSecrets(page);
           expect(await reachIntoHost(await display.frame())).toEqual(CLOSED);
         },
@@ -213,7 +228,7 @@ export function servedTests(
         `served.${mode}.no-top-navigation`,
         "content can't navigate the host's page, even after a click",
         async ({ page }) => {
-          const display = await host.show(page, instance(`${mode}-top`));
+          const display = await showMode(page, mode, instance(`${mode}-top`));
           const frame = await display.frame();
           const before = page.url();
           const target = await host.canary(`${mode}-top`);
@@ -246,7 +261,7 @@ export function servedTests(
         `served.${mode}.no-popups`,
         "content can't open a window, even after a click",
         async ({ page }) => {
-          const display = await host.show(page, instance(`${mode}-popup`));
+          const display = await showMode(page, mode, instance(`${mode}-popup`));
           const frame = await display.frame();
           const target = await host.canary(`${mode}-popup`);
           const opened: Page[] = [];
@@ -283,13 +298,13 @@ export function servedTests(
       "served.domain.storage-scope",
       "storage persists within a scope and is never shared across scopes",
       async ({ page }) => {
-        const first = await host.show(page, host.shell("scope-a"));
+        const first = await host.show(page, host.shell("scope-a"), { content: SHELL_CONTENT });
         await (await first.frame()).evaluate(() => localStorage.setItem("kept", "a"));
         await first.destroy();
-        const again = await host.show(page, host.shell("scope-a"));
+        const again = await host.show(page, host.shell("scope-a"), { content: SHELL_CONTENT });
         expect(await (await again.frame()).evaluate(() => localStorage.getItem("kept"))).toBe("a");
         expect(again.origin).toBe(first.origin);
-        const other = await host.show(page, host.shell("scope-b"));
+        const other = await host.show(page, host.shell("scope-b"), { content: SHELL_CONTENT });
         expect(other.origin).not.toBe(first.origin);
         expect(await (await other.frame()).evaluate(() => localStorage.getItem("kept"))).toBeNull();
       },
@@ -367,7 +382,7 @@ export function servedTests(
       "served.domain.egress",
       "the CSP in the document's headers closes egress",
       async ({ page }) => {
-        const display = await host.show(page, host.shell("egress"));
+        const display = await host.show(page, host.shell("egress"), { content: SHELL_CONTENT });
         const frame = await display.frame();
         const fetched = await frame.evaluate(
           async (url) => {

package/src/guide/guide.ts

@@ -1,4 +1,9 @@
-import { capabilitySpec, type CapabilityName, type Gate } from "../config/capabilities.ts";
+import {
+  MAX_COPY_CHARS,
+  capabilitySpec,
+  type CapabilityName,
+  type Gate,
+} from "../config/capabilities.ts";
 import type { PortholeConfig } from "../config/schema.ts";
 import { BUILT_IN_TOPICS } from "../config/validate.ts";
 import {
@@ -115,7 +120,7 @@ const loadsScripts = (config: PortholeConfig): boolean =>
   egressOrigins(config, "script").length > 0;
 
 /** What the sandbox withholds, from the sandbox tokens and the shell's own walls. */
-function forbidden(config: PortholeConfig): string {
+function forbidden(config: PortholeConfig, c: Context): string {
   const tokens = sandboxTokens(config);
   const items = ["position: fixed", "full screen"];
   if (!tokens.includes("allow-modals")) {
@@ -130,7 +135,11 @@ function forbidden(config: PortholeConfig): string {
   if (!tokens.includes("allow-downloads")) {
     items.push("downloads");
   }
-  items.push("clipboard writes", "frames (iframe, object, embed)", "WebRTC");
+  items.push(
+    c.global("copyText") ? "the clipboard (copy buttons call copyText)" : "the clipboard",
+    "frames (iframe, object, embed)",
+    "WebRTC",
+  );
   return `Not allowed: ${items.join(", ")}.`;
 }
 
@@ -172,7 +181,7 @@ function widget(c: Context): string {
     "- Cards in a row wrap (flex-wrap: wrap; flex: 1 1 100px), or a grid of repeat(auto-fit, minmax(160px, 1fr)): at most 2 columns under 500 px, never a fixed repeat(3, …).",
     "- Touch: anything clickable is at least 44 px tall. Phones don't hover: what a hover shows, a tap (click) shows too.",
     "",
-    `${forbidden(config)} ${network(config)} Keep it under ${Math.floor(limits.maxBytes / 1000)} KB.`,
+    `${forbidden(config, c)} ${network(config)} Keep it under ${Math.floor(limits.maxBytes / 1000)} KB.`,
     loadsScripts(config)
       ? "\nLibraries: pin an exact version at least two weeks old (chart.js@4.4.1 in its URL), never @latest or a range, so the code can't be swapped under you and draws the same every time."
       : null,
@@ -337,6 +346,12 @@ const ENTRIES: { readonly [N in CapabilityName]: (c: Context, gates: readonly Ga
       `- Data: the MCP Apps request resources/read (with the App SDK, app.readServerResource). ${gateWords(gates, "the request")}`,
     setModelContext: (_c, gates) =>
       `- Context for the agent: the MCP Apps request ui/update-model-context (with the App SDK, app.updateModelContext). ${gateWords(gates, "it")}`,
+    copyText: (c, gates) =>
+      c.global("copyText")
+        ? `- copyText(text): copies text to the person's clipboard (at most ${MAX_COPY_CHARS.toLocaleString("en-US")} characters), and the app shows them what was copied. Use it for every copy button: nothing else in the ${c.noun} can write the clipboard. ${gateWords(gates, "the text")} It returns a promise: true if it was copied.`
+        : `- Copying: the request porthole/copy-text with { text } (at most ${MAX_COPY_CHARS.toLocaleString("en-US")} characters) copies text to the person's clipboard, and the app shows them what was copied; nothing else in the ${c.noun} can write the clipboard. ${gateWords(gates, "the text")}`,
+    annotate: (c) =>
+      `- Comments: the person may point at parts of the ${c.noun} to comment on them. Give headings and the parts that matter stable ids (id="revenue"), so comments stay on them when the ${c.noun} is written again.`,
     reportError: (c, gates) =>
       `- Errors: what your code throws, and anything the sandbox blocks, is reported to the app (at most ${c.config.limits.maxErrorReports} a run). ${gateWords(gates, "it")}`.trim(),
     resize: () => "",
@@ -353,7 +368,9 @@ function interactive(c: Context): string {
   const state =
     config.isolation === "opaque"
       ? `- State isn't saved: localStorage works but lasts only while the ${noun} is on screen, and a reload or another device starts fresh. Keep what matters in the ${noun}'s code.`
-      : `- localStorage is kept for this ${noun} in this browser; another device starts fresh.`;
+      : config.storage?.shared === undefined
+        ? `- localStorage is kept for this ${noun} in this browser; another device starts fresh.`
+        : `- localStorage is shared by every ${noun} in this ${config.storage.shared}, in this browser (another device starts fresh): prefix your keys with a name of this ${noun}'s own ("budget:filters", not "filters"), or ${noun}s overwrite each other.`;
   const none =
     entries.length === 0
       ? `- It can only draw: it has no way to send anything to you or the app.`

package/src/host/clipboard.ts

@@ -0,0 +1,41 @@
+/**
+ * Writing the clipboard from the host's page, for a `copyText` handler (P052): content never
+ * writes it itself (P051). The person's click in the frame gives the host's page user activation
+ * (it propagates to ancestors; measured on Chromium, WebKit and Firefox), which the write needs.
+ */
+
+/**
+ * Writes `text` to the clipboard: the async Clipboard API, else a selected text area and the copy
+ * command. Resolves whether it worked; it can fail without a recent gesture, so a host shows the
+ * text either way (and offers its own Copy button when it failed).
+ */
+export async function writeClipboard(text: string, document: Document): Promise<boolean> {
+  const view = document.defaultView;
+  try {
+    if (view?.navigator.clipboard !== undefined) {
+      await view.navigator.clipboard.writeText(text);
+      return true;
+    }
+  } catch {
+    // Fall through to the copy command.
+  }
+  const focused = document.activeElement;
+  const area = document.createElement("textarea");
+  area.value = text;
+  area.setAttribute("readonly", "");
+  area.setAttribute("aria-hidden", "true");
+  area.style.cssText =
+    "position:fixed;top:0;left:0;width:1px;height:1px;opacity:0;pointer-events:none;border:0;padding:0";
+  try {
+    document.body.append(area);
+    area.select();
+    return document.execCommand("copy");
+  } catch {
+    return false;
+  } finally {
+    area.remove();
+    if (focused !== null && typeof (focused as HTMLElement).focus === "function") {
+      (focused as HTMLElement).focus({ preventScroll: true });
+    }
+  }
+}