@botiverse/porthole 0.1.2 → 0.1.4

package/dist/annotate/types.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Annotations (P053): a person points at part of a display (an element, or text they select) to
+ * comment on it, and the host marks the anchors already made. The host drives the shell with
+ * Porthole's own messages (`porthole/annotate.*`); the shell answers with anchors and where they
+ * are. An anchor is a set of W3C Web Annotation selectors, so it can be found again after the
+ * content changes; finding it is best-effort, and says so (`orphaned`).
+ *
+ * Everything the frame reports is the content's word: the shell shares its realm with the
+ * content, which can interfere or fake a report. The host checks each report's shape and size
+ * and takes reports only while it asked for them. Use them as UI hints (where to draw a comment,
+ * what to quote), never as permissions.
+ */
+/** The element a CSS selector matches (W3C `CssSelector`). */
+export interface CssSelector {
+    readonly type: "CssSelector";
+    readonly value: string;
+}
+/** Text, with a little of what comes before and after it (W3C `TextQuoteSelector`). */
+export interface TextQuoteSelector {
+    readonly type: "TextQuoteSelector";
+    readonly exact: string;
+    readonly prefix?: string;
+    readonly suffix?: string;
+}
+/**
+ * Offsets into the document's text: the text of the body's text nodes, in order, without
+ * scripts, styles and templates (W3C `TextPositionSelector`).
+ */
+export interface TextPositionSelector {
+    readonly type: "TextPositionSelector";
+    readonly start: number;
+    readonly end: number;
+}
+export type AnnotationSelector = CssSelector | TextQuoteSelector | TextPositionSelector;
+export interface AnnotationAnchor {
+    /** What the person pointed at: an element, or a text selection. */
+    readonly kind: "element" | "text";
+    /** At most one of each type; tried in turn when the anchor is found again. */
+    readonly selectors: readonly AnnotationSelector[];
+    /** A short description for the host to show ("h2#revenue Revenue grew 12%"); the content's. */
+    readonly label: string;
+}
+/** A box in the frame's viewport, CSS px: add the frame element's position to place it on the page. */
+export interface AnnotationRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** What the person may point at while the host is asking. */
+export interface AnnotateMode {
+    /** Elements, picked with a click or tap (the one under the pointer is outlined); one pick. */
+    readonly elements?: boolean;
+    /** Text, by selecting it: each settled selection is reported, and its clearing. */
+    readonly text?: boolean;
+}
+/** An anchor the host marks in the frame, under its own id. */
+export interface AnnotationMark {
+    readonly id: string;
+    readonly anchor: AnnotationAnchor;
+}
+/** Whether a mark's anchor was found in the content as it is now. */
+export type AnchorState = "attached" | "orphaned";
+export interface AnchorResult {
+    readonly id: string;
+    readonly state: AnchorState;
+    /** Where it is now, when attached. */
+    readonly rect?: AnnotationRect;
+}
+/** What the frame reports, once the host has checked it. */
+export type AnnotationReport = 
+/** The person pointed at an element or settled a text selection. */
+{
+    readonly type: "selected";
+    readonly anchor: AnnotationAnchor;
+    readonly rect: AnnotationRect;
+}
+/** The text selection went away. */
+ | {
+    readonly type: "unselected";
+}
+/** The person pressed Escape while picking an element. */
+ | {
+    readonly type: "cancelled";
+}
+/** Where the marked anchors are now, after `show`, `focus`, or a change of the content. */
+ | {
+    readonly type: "anchored";
+    readonly results: readonly AnchorResult[];
+};
+/** Porthole's own messages for annotations (own-prefixed, P002). */
+export declare const ANNOTATE_METHODS: {
+    /** Host → frame: let the person point (`AnnotateMode`). */
+    readonly start: "porthole/annotate.start";
+    /** Host → frame: stop. */
+    readonly stop: "porthole/annotate.stop";
+    /** Host → frame: mark these anchors (replacing what was marked). */
+    readonly show: "porthole/annotate.show";
+    /** Host → frame: bring one mark into view and make it the active one. */
+    readonly focus: "porthole/annotate.focus";
+    /** Host → frame: remove every mark. */
+    readonly clear: "porthole/annotate.clear";
+    /** Frame → host. */
+    readonly selected: "porthole/annotate.selected";
+    readonly unselected: "porthole/annotate.unselected";
+    readonly cancelled: "porthole/annotate.cancelled";
+    readonly anchored: "porthole/annotate.anchored";
+};
+/** The most of each part of an anchor or report the host takes. */
+export declare const ANNOTATION_LIMITS: {
+    readonly label: 120;
+    readonly cssSelector: 1000;
+    readonly exact: 4000;
+    readonly context: 64;
+    /** The most marks one `show` carries, and results one report. */
+    readonly marks: 500;
+    readonly id: 128;
+    readonly position: 50000000;
+    readonly coordinate: 10000000;
+};

package/dist/annotate/types.js

@@ -0,0 +1,42 @@
+/**
+ * Annotations (P053): a person points at part of a display (an element, or text they select) to
+ * comment on it, and the host marks the anchors already made. The host drives the shell with
+ * Porthole's own messages (`porthole/annotate.*`); the shell answers with anchors and where they
+ * are. An anchor is a set of W3C Web Annotation selectors, so it can be found again after the
+ * content changes; finding it is best-effort, and says so (`orphaned`).
+ *
+ * Everything the frame reports is the content's word: the shell shares its realm with the
+ * content, which can interfere or fake a report. The host checks each report's shape and size
+ * and takes reports only while it asked for them. Use them as UI hints (where to draw a comment,
+ * what to quote), never as permissions.
+ */
+/** Porthole's own messages for annotations (own-prefixed, P002). */
+export const ANNOTATE_METHODS = {
+    /** Host → frame: let the person point (`AnnotateMode`). */
+    start: "porthole/annotate.start",
+    /** Host → frame: stop. */
+    stop: "porthole/annotate.stop",
+    /** Host → frame: mark these anchors (replacing what was marked). */
+    show: "porthole/annotate.show",
+    /** Host → frame: bring one mark into view and make it the active one. */
+    focus: "porthole/annotate.focus",
+    /** Host → frame: remove every mark. */
+    clear: "porthole/annotate.clear",
+    /** Frame → host. */
+    selected: "porthole/annotate.selected",
+    unselected: "porthole/annotate.unselected",
+    cancelled: "porthole/annotate.cancelled",
+    anchored: "porthole/annotate.anchored",
+};
+/** The most of each part of an anchor or report the host takes. */
+export const ANNOTATION_LIMITS = {
+    label: 120,
+    cssSelector: 1_000,
+    exact: 4_000,
+    context: 64,
+    /** The most marks one `show` carries, and results one report. */
+    marks: 500,
+    id: 128,
+    position: 50_000_000,
+    coordinate: 10_000_000,
+};

package/dist/annotate/validate.d.ts

@@ -0,0 +1,11 @@
+import { type AnnotateMode, type AnnotationAnchor, type AnnotationMark, type AnnotationRect, type AnnotationReport } from "./types.ts";
+/** An anchor, rebuilt from its known fields; null if any part is malformed or too large. */
+export declare function parseAnchor(value: unknown): AnnotationAnchor | null;
+/** A box in the frame's viewport; null unless every number is finite and sizes aren't negative. */
+export declare function parseRect(value: unknown): AnnotationRect | null;
+/** A report from the frame, checked; null if malformed (it is then dropped). */
+export declare function parseReport(value: unknown): AnnotationReport | null;
+/** What the host may start with: elements, text, or both (default both). */
+export declare function annotateMode(mode: AnnotateMode | undefined): Required<AnnotateMode>;
+/** The host's marks, checked before they go to the frame; throws on the first bad one. */
+export declare function checkMarks(marks: readonly AnnotationMark[]): AnnotationMark[];

package/dist/annotate/validate.js

@@ -0,0 +1,156 @@
+import { ANNOTATION_LIMITS as LIMITS, } from "./types.js";
+/**
+ * The host's checks on what a frame says about annotations (P053), and on anchors a host stores
+ * and sends back. Each rebuilds what it accepts from known fields only, within `ANNOTATION_LIMITS`,
+ * and answers null for anything else: a report is dropped whole, never repaired.
+ */
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const text = (value, max, min = 0) => typeof value === "string" && value.length >= min && value.length <= max;
+const count = (value, max) => typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= max;
+function selector(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    switch (value.type) {
+        case "CssSelector":
+            return text(value.value, LIMITS.cssSelector, 1)
+                ? { type: "CssSelector", value: value.value }
+                : null;
+        case "TextQuoteSelector": {
+            const { exact, prefix, suffix } = value;
+            if (!text(exact, LIMITS.exact, 1) ||
+                (prefix !== undefined && !text(prefix, LIMITS.context)) ||
+                (suffix !== undefined && !text(suffix, LIMITS.context))) {
+                return null;
+            }
+            return {
+                type: "TextQuoteSelector",
+                exact,
+                ...(prefix === undefined || prefix === "" ? {} : { prefix }),
+                ...(suffix === undefined || suffix === "" ? {} : { suffix }),
+            };
+        }
+        case "TextPositionSelector":
+            return count(value.start, LIMITS.position) &&
+                count(value.end, LIMITS.position) &&
+                value.start <= value.end
+                ? { type: "TextPositionSelector", start: value.start, end: value.end }
+                : null;
+        default:
+            return null;
+    }
+}
+/** An anchor, rebuilt from its known fields; null if any part is malformed or too large. */
+export function parseAnchor(value) {
+    if (!isRecord(value) || (value.kind !== "element" && value.kind !== "text")) {
+        return null;
+    }
+    if (!Array.isArray(value.selectors) || value.selectors.length === 0) {
+        return null;
+    }
+    if (value.selectors.length > 3 || !text(value.label, LIMITS.label)) {
+        return null;
+    }
+    const selectors = [];
+    for (const each of value.selectors) {
+        const parsed = selector(each);
+        if (parsed === null || selectors.some((other) => other.type === parsed.type)) {
+            return null;
+        }
+        selectors.push(parsed);
+    }
+    // A text anchor is found by its words; an element one needs a way to find the element.
+    const quote = selectors.some((each) => each.type === "TextQuoteSelector");
+    const css = selectors.some((each) => each.type === "CssSelector");
+    if (value.kind === "text" ? !quote : !css && !quote) {
+        return null;
+    }
+    return { kind: value.kind, selectors, label: value.label };
+}
+const coordinate = (value) => typeof value === "number" && Number.isFinite(value) && Math.abs(value) <= LIMITS.coordinate;
+/** A box in the frame's viewport; null unless every number is finite and sizes aren't negative. */
+export function parseRect(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const { x, y, width, height } = value;
+    if (!coordinate(x) || !coordinate(y) || !coordinate(width) || !coordinate(height)) {
+        return null;
+    }
+    if (width < 0 || height < 0) {
+        return null;
+    }
+    return { x, y, width, height };
+}
+const markId = (value) => text(value, LIMITS.id, 1);
+function results(value) {
+    if (!Array.isArray(value) || value.length > LIMITS.marks) {
+        return null;
+    }
+    const out = [];
+    for (const each of value) {
+        if (!isRecord(each) || !markId(each.id)) {
+            return null;
+        }
+        if (each.state === "orphaned") {
+            out.push({ id: each.id, state: "orphaned" });
+            continue;
+        }
+        if (each.state !== "attached") {
+            return null;
+        }
+        const rect = each.rect === undefined ? undefined : parseRect(each.rect);
+        if (rect === null) {
+            return null;
+        }
+        out.push({ id: each.id, state: "attached", ...(rect === undefined ? {} : { rect }) });
+    }
+    return out;
+}
+/** A report from the frame, checked; null if malformed (it is then dropped). */
+export function parseReport(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    switch (value.type) {
+        case "selected": {
+            const anchor = parseAnchor(value.anchor);
+            const rect = parseRect(value.rect);
+            return anchor === null || rect === null ? null : { type: "selected", anchor, rect };
+        }
+        case "unselected":
+            return { type: "unselected" };
+        case "cancelled":
+            return { type: "cancelled" };
+        case "anchored": {
+            const checked = results(value.results);
+            return checked === null ? null : { type: "anchored", results: checked };
+        }
+        default:
+            return null;
+    }
+}
+/** What the host may start with: elements, text, or both (default both). */
+export function annotateMode(mode) {
+    const elements = mode?.elements ?? true;
+    const words = mode?.text ?? true;
+    if (typeof elements !== "boolean" || typeof words !== "boolean" || (!elements && !words)) {
+        throw new TypeError("annotations.start: elements, text, or both");
+    }
+    return { elements, text: words };
+}
+/** The host's marks, checked before they go to the frame; throws on the first bad one. */
+export function checkMarks(marks) {
+    if (!Array.isArray(marks) || marks.length > LIMITS.marks) {
+        throw new TypeError(`annotations.show: at most ${LIMITS.marks} marks`);
+    }
+    const seen = new Set();
+    return marks.map((mark, index) => {
+        const anchor = parseAnchor(mark?.anchor);
+        if (!markId(mark?.id) || seen.has(mark.id) || anchor === null) {
+            throw new TypeError(`annotations.show: mark ${index} needs a unique id (1 to ${LIMITS.id} characters) and a valid anchor`);
+        }
+        seen.add(mark.id);
+        return { id: mark.id, anchor };
+    });
+}

package/dist/bridge/bridge.d.ts

@@ -1,4 +1,5 @@
 import { type CapabilityName } from "../config/capabilities.ts";
+import type { AnnotationReport } from "../annotate/types.ts";
 import type { PortholeConfig } from "../config/schema.ts";
 import type { CapabilityHandlers, Confirm, HostFunctionBridge, Refusal } from "./types.ts";
 /**
@@ -13,6 +14,9 @@ export type BridgeEvent = {
 } | {
     readonly type: "error";
     readonly message: string;
+} | {
+    readonly type: "annotation";
+    readonly report: AnnotationReport;
 } | {
     readonly type: "refused";
     readonly capability: CapabilityName;

package/dist/bridge/bridge.js

@@ -1,4 +1,5 @@
-import { capabilitySpec, } from "../config/capabilities.js";
+import { MAX_COPY_CHARS, capabilitySpec, } from "../config/capabilities.js";
+import { parseReport } from "../annotate/validate.js";
 import { effectiveGates } from "../compile/policy.js";
 const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 const MAX_URL = 4_096;
@@ -74,6 +75,13 @@ const VALIDATORS = {
             ? { message: message.slice(0, 2_000) }
             : null;
     },
+    copyText: (args) => {
+        const text = isRecord(args) ? args.text : undefined;
+        return typeof text === "string" && text !== "" && text.length <= MAX_COPY_CHARS
+            ? { text }
+            : null;
+    },
+    annotate: (args) => parseReport(args),
     resize: (args) => {
         if (!isRecord(args) ||
             typeof args.height !== "number" ||
@@ -173,6 +181,9 @@ export function createBridge(options) {
                     const size = args;
                     onEvent({ type: "resize", ...size });
                 }
+                else if (capability === "annotate") {
+                    onEvent({ type: "annotation", report: args });
+                }
                 else {
                     onEvent({ type: "error", message: args.message });
                 }

package/dist/compile/policy.d.ts

@@ -33,9 +33,10 @@ export declare function serializeCsp(directives: readonly CspDirective[]): strin
  */
 export declare function sandboxTokens(config: PortholeConfig): string[];
 /**
- * The frame's `allow` attribute (Permissions Policy). Empty: no camera, microphone, geolocation,
- * clipboard, fullscreen or other powerful feature is delegated to the frame; a url-mode config
- * may delegate clipboard writes and full screen to the app's own origin (P049).
+ * The frame's `allow` attribute (Permissions Policy). No camera, microphone, geolocation,
+ * fullscreen or other powerful feature is delegated to the frame, and the clipboard is denied by
+ * name (P051): content never writes it, the host does (`copyText`). A url-mode config may
+ * delegate clipboard writes and full screen to the app's own origin (P049).
  */
 export declare function allowAttribute(config: PortholeConfig): string;
 /**
@@ -54,3 +55,9 @@ export declare function embedderFrameSources(config: PortholeConfig): string[];
  * engine Porthole supports reads frames from `frame-src`, P038).
  */
 export declare function embedderCsp(configs: readonly PortholeConfig[]): string;
+/**
+ * The `frame-src` sources the embedding page must allow for every kind of display it shows, as a
+ * list, for a host that writes its own policy around them (empty: it frames nothing of
+ * Porthole's but `srcdoc`, which needs none).
+ */
+export declare function embedderFrameSourcesOf(configs: readonly PortholeConfig[]): string[];

package/dist/compile/policy.js

@@ -74,12 +74,15 @@ export function sandboxTokens(config) {
     }
 }
 /**
- * The frame's `allow` attribute (Permissions Policy). Empty: no camera, microphone, geolocation,
- * clipboard, fullscreen or other powerful feature is delegated to the frame; a url-mode config
- * may delegate clipboard writes and full screen to the app's own origin (P049).
+ * The frame's `allow` attribute (Permissions Policy). No camera, microphone, geolocation,
+ * fullscreen or other powerful feature is delegated to the frame, and the clipboard is denied by
+ * name (P051): content never writes it, the host does (`copyText`). A url-mode config may
+ * delegate clipboard writes and full screen to the app's own origin (P049).
  */
 export function allowAttribute(config) {
-    return config.mode === "url" ? (config.permissions ?? []).join("; ") : "";
+    return config.mode === "url"
+        ? (config.permissions ?? []).join("; ")
+        : "clipboard-read 'none'; clipboard-write 'none'";
 }
 /**
  * The `frame-src` sources the EMBEDDING page must allow, and nothing else: a frame's own CSP can't
@@ -99,6 +102,14 @@ export function embedderFrameSources(config) {
  * engine Porthole supports reads frames from `frame-src`, P038).
  */
 export function embedderCsp(configs) {
-    const sources = unique(configs.flatMap(embedderFrameSources));
+    const sources = embedderFrameSourcesOf(configs);
     return serializeCsp([["frame-src", ...(sources.length === 0 ? ["'none'"] : sources)]]);
 }
+/**
+ * The `frame-src` sources the embedding page must allow for every kind of display it shows, as a
+ * list, for a host that writes its own policy around them (empty: it frames nothing of
+ * Porthole's but `srcdoc`, which needs none).
+ */
+export function embedderFrameSourcesOf(configs) {
+    return unique(configs.flatMap(embedderFrameSources));
+}

package/dist/config/capabilities.d.ts

@@ -1,3 +1,4 @@
+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
@@ -7,7 +8,7 @@
  * are on by default), and is served either by a handler the host passes or as an event the
  * framework emits.
  */
-export declare const CAPABILITY_NAMES: readonly ["sendPrompt", "openLink", "downloadFile", "callTool", "readData", "setModelContext", "reportError", "resize"];
+export declare const CAPABILITY_NAMES: readonly ["sendPrompt", "openLink", "downloadFile", "callTool", "readData", "setModelContext", "reportError", "resize", "copyText", "annotate"];
 export type CapabilityName = (typeof CAPABILITY_NAMES)[number];
 /**
  * What must hold before a call reaches the host's handler. A capability's gates all apply.
@@ -32,14 +33,17 @@ 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 sdk?: string;
     };
 }
+/** The most text one `copyText` call carries. */
+export declare const MAX_COPY_CHARS = 20000;
 export declare const CAPABILITIES: {
     readonly sendPrompt: {
         readonly defaultGates: readonly ["user-activation", "confirm"];
@@ -99,6 +103,27 @@ export declare const CAPABILITIES: {
         readonly defaultGates: readonly [];
         readonly 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).
+     */
+    readonly copyText: {
+        readonly defaultGates: readonly ["user-activation", Gate];
+        readonly served: "handler";
+        readonly global: "copyText";
+        readonly request: {
+            readonly 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.
+     */
+    readonly annotate: {
+        readonly defaultGates: readonly [Gate];
+        readonly served: "event";
+    };
 };
 /** The arguments a call carries, once the adapter has validated them. */
 export interface CapabilityArgs {
@@ -130,6 +155,11 @@ export interface CapabilityArgs {
         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. */
 export interface CapabilityResults {
@@ -144,6 +174,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. */
 export type HandledCapability = {

package/dist/config/capabilities.js

@@ -16,8 +16,12 @@ export const CAPABILITY_NAMES = [
     "setModelContext",
     "reportError",
     "resize",
+    "copyText",
+    "annotate",
 ];
 const rate = (perMinute) => ({ rateLimit: { perMinute } });
+/** The most text one `copyText` call carries. */
+export const MAX_COPY_CHARS = 20_000;
 export const CAPABILITIES = {
     sendPrompt: {
         defaultGates: ["user-activation", "confirm"],
@@ -53,6 +57,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" },
 };
 /** A capability's spec, as the general shape (the table above keeps literal types). */
 export function capabilitySpec(name) {

package/dist/config/schema.d.ts

@@ -157,4 +157,15 @@ 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/dist/config/validate.js

@@ -111,6 +111,7 @@ export function validateConfig(input) {
         "embedder",
         "sandbox",
         "permissions",
+        "storage",
     ], "config");
     if (!MODES.includes(config.mode)) {
         fail("config.mode", `must be one of ${MODES.join(", ")}`);
@@ -258,6 +259,17 @@ export function validateConfig(input) {
             }
         });
     }
+    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/dist/conformance/clipboard.d.ts

@@ -0,0 +1,2 @@
+import { type Probe } from "./kit.ts";
+export declare const CLIPBOARD_PROBES: readonly Probe[];