@penpair/core 0.4.1 → 0.5.0

package/dist/design-releases/copy.js

@@ -0,0 +1,466 @@
+import { randomUUID } from "node:crypto";
+import { lstat } from "node:fs/promises";
+import { commandSleep } from "../command-result.js";
+import { writeCoordinator } from "../coordination.js";
+import { guardFile } from "../file-guard.js";
+import { runJournaledSteps, readJournalTarget, readJournal, listJournals, observationHash, JournalRunError, } from "../journal.js";
+import { withPageSession, selectPage, rememberPage } from "../page-session.js";
+import { runSnippet } from "../snippet.js";
+import { ensureGitignoreEntry } from "../instance/gitignore.js";
+import { atomicWriteFile } from "../atomic-output.js";
+import { readProjectBytes } from "../bounded-file.js";
+import { artifactPath, saveArtifact } from "./artifact-paths.js";
+import { captureReleaseScreen } from "./live.js";
+import { captureCopyEvidence, matchCopiedFrames, compareCopyEvidence, sourceEvidenceHash, } from "./copy-evidence.js";
+import { nativeCopyInspect, nativeCopyCreatePage, nativeCopySelect, nativeCopyObserve, nativeCopyArrange, } from "./copy-snippets.js";
+import { validateCopyRequest, readCopyPreview, copyRequestHash, } from "./copy-plan.js";
+const operation = "design-release-copy";
+async function observedDestination(client, fileId, pageId) {
+    await selectPage(client, {
+        id: pageId,
+    });
+    const result = await runSnippet(client, nativeCopyObserve(fileId, pageId), {
+        effect: "read",
+        retries: 0,
+    });
+    if (result.ok !== true ||
+        result.fileId !== fileId ||
+        result.pageId !== pageId ||
+        !Array.isArray(result.rootIds) ||
+        !Array.isArray(result.selectionIds) ||
+        !Array.isArray(result.rootFrames) ||
+        result.rootIds.some((id) => typeof id !== "string")) {
+        throw new Error("Destination inventory or selection was not independently observed");
+    }
+    return result;
+}
+/** Copy native boards through an explicitly supplied editor transport; preview never touches clipboard or selection. */
+export async function copyReleaseBoards(client, root, request, options = {}) {
+    validateCopyRequest(request);
+    if (options.resume && (!options.apply || !options.runId)) {
+        throw new Error("Copy resume requires --apply and the original run ID");
+    }
+    client = guardFile(client, {
+        id: request.fileId,
+    }, {
+        mode: "strict",
+    });
+    return withPageSession(client, async () => {
+        const inspect = async (ownerKey) => readCopyPreview(await runSnippet(client, nativeCopyInspect(request.fileId, request.sourcePage, request.frameIds, request.releaseVersion, ownerKey), {
+            effect: "read",
+            retries: 0,
+        }), request);
+        const current = await inspect();
+        if (!options.apply) {
+            return {
+                schemaVersion: 1,
+                kind: "native-release-copy",
+                status: "preview",
+                preview: current,
+                problems: [
+                    "Native browser copy/paste is experimental; structural and stable-render verification follow an explicit apply.",
+                ],
+            };
+        }
+        if (!options.clipboard) {
+            throw new Error("Native copy requires an explicitly configured browser clipboard transport");
+        }
+        const runId = options.runId ?? randomUUID();
+        if (!/^[A-Za-z0-9-]{1,100}$/.test(runId)) {
+            throw new Error("Invalid native copy run ID");
+        }
+        const assertNoConflictingRuns = async () => {
+            const records = await listJournals(root);
+            for (const previous of records.filter((record) => record.operation === operation && record.target.fileId === request.fileId)) {
+                if (previous.runId === runId) {
+                    continue;
+                }
+                const record = await readJournal(root, previous.runId);
+                const payload = record.payload;
+                if (previous.state !== "verified" ||
+                    (payload?.kind === "native-release-copy-plan" &&
+                        copyRequestHash(payload.request) === copyRequestHash(request))) {
+                    throw new Error(`Copy run ${previous.runId} already covers this transfer or requires reconciliation; use its explicit --resume before another paste`);
+                }
+            }
+        };
+        await assertNoConflictingRuns();
+        await ensureGitignoreEntry(root, ".penpair", {
+            directory: true,
+            comment: "penpair: private operation evidence",
+        });
+        const prefix = `.penpair/native-copy/${runId}`;
+        const fencePath = await artifactPath(root, `${prefix}/paste-attempt.json`, true);
+        let payload;
+        let attempted = false;
+        let pageAttempted = false;
+        if (options.resume) {
+            const previous = await readJournal(root, runId);
+            pageAttempted = previous.steps.some((step) => step.key === "page" && step.state !== "pending");
+            payload = previous.payload;
+            if (!payload ||
+                payload.kind !== "native-release-copy-plan" ||
+                copyRequestHash(payload.request) !== copyRequestHash(request)) {
+                throw new Error("Copy resume inputs changed; no clipboard operation was dispatched");
+            }
+            // The durable fence is written before the only paste call. A started
+            // journal step may have stopped earlier during page/selection preparation.
+            try {
+                await lstat(fencePath);
+                attempted = true;
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    throw error;
+                }
+            }
+        }
+        else {
+            const sources = await captureCopyEvidence(client, root, request.fileId, current.sourcePageId, request.frameIds, `${prefix}/source`, options.redact);
+            payload = {
+                kind: "native-release-copy-plan",
+                request,
+                preview: current,
+                sources,
+            };
+            await saveArtifact(root, `${prefix}/plan.json`, `${JSON.stringify(payload)}\n`, options.redact);
+        }
+        if (Buffer.byteLength(JSON.stringify(payload)) > 16 * 1024 * 1024) {
+            throw new Error("Native transfer plan exceeds 16 MiB");
+        }
+        const baseline = payload.preview;
+        let pinnedDestinationId = baseline.destinationPageId;
+        const readSource = async () => {
+            for (const source of payload.sources) {
+                const observed = await captureReleaseScreen(client, request.fileId, baseline.sourcePageId, source.frameId);
+                if (observationHash(observed.nodes) !== observationHash(source.inspection.nodes)) {
+                    throw new Error("Source board content changed; retain the run and make a new reviewed plan");
+                }
+            }
+        };
+        const targetPreview = async () => {
+            const value = await inspect(runId);
+            if (!baseline.destinationPageId &&
+                value.destinationPageId &&
+                value.createdPageOwner !== runId) {
+                throw new Error("A different page appeared at the planned destination");
+            }
+            if (pinnedDestinationId && value.destinationPageId !== pinnedDestinationId) {
+                throw new Error("Pinned destination page was replaced or renamed");
+            }
+            if (value.destinationPageId) {
+                pinnedDestinationId = value.destinationPageId;
+            }
+            if (value.sourcePageId !== baseline.sourcePageId ||
+                (baseline.destinationPageId && value.destinationPageId !== baseline.destinationPageId)) {
+                throw new Error("Pinned copy page identity changed");
+            }
+            return value;
+        };
+        const addedRoots = (value) => value.destinationRootIds.filter((id) => !baseline.destinationRootIds.includes(id));
+        const inventoryComplete = (value) => addedRoots(value).length === request.frameIds.length &&
+            baseline.destinationRootIds.every((id) => value.destinationRootIds.includes(id));
+        const pasteComplete = (value) => attempted &&
+            inventoryComplete(value) &&
+            pairs.length === request.frameIds.length &&
+            pairs.every((pair) => addedRoots(value).includes(pair.targetFrameId));
+        let pairs = [];
+        let placements = [];
+        const mappingPath = `${prefix}/mapping.json`;
+        try {
+            await artifactPath(root, mappingPath);
+            const saved = JSON.parse((await readProjectBytes(root, mappingPath, 1024 * 1024)).toString("utf8"));
+            if (saved.requestHash !== copyRequestHash(request) ||
+                !Array.isArray(saved.pairs) ||
+                saved.pairs.length !== request.frameIds.length ||
+                saved.pairs.some((pair, index) => !pair ||
+                    pair.sourceFrameId !== request.frameIds[index] ||
+                    typeof pair.targetFrameId !== "string") ||
+                new Set(saved.pairs.map((pair) => pair.targetFrameId)).size !==
+                    saved.pairs.length) {
+                throw new Error("Saved native copy mapping is invalid");
+            }
+            pairs = saved.pairs;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+        const calculatePlacements = () => {
+            let x = 0;
+            const y = Math.max(1000, baseline.destinationBounds.bottom + 160);
+            return pairs.map((pair) => {
+                const source = baseline.sourceFrames.find((frame) => frame.id === pair.sourceFrameId);
+                const placement = {
+                    id: pair.targetFrameId,
+                    x,
+                    y,
+                };
+                x += source.width + 160;
+                return placement;
+            });
+        };
+        const identifyPasted = async () => {
+            const value = await targetPreview();
+            if (!attempted || !inventoryComplete(value) || !value.destinationPageId) {
+                return value;
+            }
+            if (!pairs.length) {
+                const observed = await observedDestination(client, request.fileId, value.destinationPageId);
+                const ids = addedRoots(value);
+                if (observationHash([
+                    ...observed.selectionIds,
+                ].sort()) !==
+                    observationHash([
+                        ...ids,
+                    ].sort())) {
+                    throw new Error("Pasted selection does not uniquely identify the new boards; inspect without replay");
+                }
+                const targets = await captureCopyEvidence(client, root, request.fileId, value.destinationPageId, ids, `${prefix}/pasted-${randomUUID()}`, options.redact);
+                pairs = matchCopiedFrames(payload.sources, targets);
+                await saveArtifact(root, mappingPath, JSON.stringify({
+                    requestHash: copyRequestHash(request),
+                    pairs,
+                }), options.redact);
+            }
+            placements = calculatePlacements();
+            return value;
+        };
+        const arrangementState = async () => {
+            const value = await identifyPasted();
+            if (!value.destinationPageId || !pasteComplete(value)) {
+                return value;
+            }
+            const observed = await observedDestination(client, request.fileId, value.destinationPageId);
+            value.arranged = placements.every((placement) => observed.rootFrames.some((frame) => frame.id === placement.id &&
+                frame.x === placement.x &&
+                frame.y === placement.y &&
+                frame.copyRunId === runId));
+            return value;
+        };
+        const pageStep = {
+            key: "page",
+            label: "Prepare the release destination page",
+            signature: nativeCopyCreatePage(request.fileId, request.releaseVersion, runId).code,
+            inspect: targetPreview,
+            apply: async () => {
+                await readSource();
+                pageAttempted = true;
+                const result = await runSnippet(client, nativeCopyCreatePage(request.fileId, request.releaseVersion, runId), {
+                    effect: "write",
+                    retries: 0,
+                });
+                if (typeof result.pageId !== "string") {
+                    throw new Error("Created release page identity was not acknowledged");
+                }
+                rememberPage(client, {
+                    fileId: request.fileId,
+                    pageId: result.pageId,
+                });
+                return result;
+            },
+            verify: (value) => Boolean(value.destinationPageId) && value.destinationNamed !== false,
+            reconcile: (_before, value) => value.destinationPageId && value.destinationNamed !== false
+                ? "complete"
+                : pageAttempted && !value.destinationPageId
+                    ? "conflict"
+                    : "pending",
+        };
+        const pasteStep = {
+            key: "paste",
+            label: "Copy selected native boards and paste once",
+            signature: "native-clipboard-batch-v1-no-replay",
+            inspect: identifyPasted,
+            apply: async (value) => {
+                if (attempted ||
+                    !value.destinationPageId ||
+                    addedRoots(value).length ||
+                    !baseline.destinationRootIds.every((id) => value.destinationRootIds.includes(id))) {
+                    throw new Error("Paste is fenced or destination changed; inspect without replaying");
+                }
+                await readSource();
+                const clipboard = await options.clipboard();
+                try {
+                    await selectPage(client, {
+                        id: baseline.sourcePageId,
+                    });
+                    await runSnippet(client, nativeCopySelect(request.fileId, baseline.sourcePageId, request.frameIds), {
+                        effect: "write",
+                        retries: 0,
+                    });
+                    const selection = await observedDestination(client, request.fileId, baseline.sourcePageId);
+                    if (observationHash([
+                        ...selection.selectionIds,
+                    ].sort()) !==
+                        observationHash([
+                            ...request.frameIds,
+                        ].sort())) {
+                        throw new Error("Source board selection changed before copy");
+                    }
+                    await clipboard.copy(baseline.sourcePageId, request.frameIds);
+                    await selectPage(client, {
+                        id: value.destinationPageId,
+                    });
+                    await runSnippet(client, nativeCopySelect(request.fileId, value.destinationPageId, []), {
+                        effect: "write",
+                        retries: 0,
+                    });
+                    const destination = await targetPreview();
+                    if (observationHash(destination.destinationRootIds) !==
+                        observationHash(baseline.destinationRootIds)) {
+                        throw new Error("Destination changed before paste");
+                    }
+                    const empty = await observedDestination(client, request.fileId, value.destinationPageId);
+                    if (empty.selectionIds.length) {
+                        throw new Error("Destination selection changed before paste");
+                    }
+                    await atomicWriteFile(fencePath, JSON.stringify({
+                        schemaVersion: 1,
+                        runId,
+                        fileId: request.fileId,
+                        pageId: value.destinationPageId,
+                        requestHash: copyRequestHash(request),
+                    }));
+                    attempted = true;
+                    await clipboard.paste(value.destinationPageId);
+                    for (let poll = 0; poll < 25; poll++) {
+                        if (inventoryComplete(await targetPreview())) {
+                            return {
+                                dispatched: true,
+                            };
+                        }
+                        await (options.sleep ?? commandSleep)(200);
+                    }
+                    throw new Error("Paste acknowledgment did not establish new boards; reconcile without replay");
+                }
+                finally {
+                    await clipboard.close();
+                }
+            },
+            verify: pasteComplete,
+            reconcile: (_before, value) => pasteComplete(value)
+                ? "complete"
+                : attempted || addedRoots(value).length
+                    ? "conflict"
+                    : "pending",
+        };
+        const arrangeStep = {
+            key: "arrange",
+            label: "Identify and arrange only the new native copies",
+            signature: "native-copy-arrange-v1",
+            inspect: arrangementState,
+            apply: async (value) => {
+                if (!value.destinationPageId || !pasteComplete(value)) {
+                    throw new Error("Copied root inventory is incomplete");
+                }
+                placements = calculatePlacements();
+                await readSource();
+                await selectPage(client, {
+                    id: value.destinationPageId,
+                });
+                return runSnippet(client, nativeCopyArrange(request.fileId, value.destinationPageId, placements, runId), {
+                    effect: "write",
+                    retries: 0,
+                });
+            },
+            verify: (value) => pasteComplete(value) && value.arranged === true,
+            reconcile: (_before, value) => pasteComplete(value) ? (value.arranged === true ? "complete" : "pending") : "conflict",
+        };
+        let finalResult;
+        let receiptPersisted = false;
+        try {
+            await runJournaledSteps([
+                pageStep,
+                pasteStep,
+                arrangeStep,
+            ], {
+                root,
+                operation,
+                input: request,
+                payload,
+                runId,
+                resume: options.resume,
+                target: () => readJournalTarget(client),
+                coordinate: async (identity, target) => {
+                    const lease = await writeCoordinator(client, {
+                        root,
+                        operation,
+                        warn: options.onStep,
+                    })(identity, target);
+                    try {
+                        await assertNoConflictingRuns();
+                        return lease;
+                    }
+                    catch (error) {
+                        await lease.release();
+                        throw error;
+                    }
+                },
+                redact: options.redact,
+                onStep: options.onStep,
+                finalVerify: async () => {
+                    const destination = await arrangementState();
+                    if (!destination.destinationPageId ||
+                        !pasteComplete(destination) ||
+                        !destination.arranged) {
+                        return false;
+                    }
+                    const targets = await captureCopyEvidence(client, root, request.fileId, destination.destinationPageId, pairs.map((pair) => pair.targetFrameId), `${prefix}/target-${randomUUID()}`, options.redact);
+                    const verifiedPairs = matchCopiedFrames(payload.sources, targets);
+                    if (observationHash(verifiedPairs) !== observationHash(pairs)) {
+                        throw new Error("Copied identities changed before final readback");
+                    }
+                    const verification = compareCopyEvidence(payload.sources, targets, pairs);
+                    const originals = await captureCopyEvidence(client, root, request.fileId, baseline.sourcePageId, request.frameIds, `${prefix}/source-readback-${randomUUID()}`, options.redact);
+                    if (sourceEvidenceHash(originals) !== sourceEvidenceHash(payload.sources)) {
+                        throw new Error("Original boards changed during transfer; independent reconciliation is required");
+                    }
+                    await selectPage(client, {
+                        id: destination.destinationPageId,
+                    });
+                    finalResult = {
+                        schemaVersion: 1,
+                        kind: "native-release-copy",
+                        status: verification.nativeVerified && verification.pixelsMatch ? "copied" : "incomplete",
+                        preview: destination,
+                        runId,
+                        receiptPath: `${prefix}/receipt.json`,
+                        pairs,
+                        nativeVerified: verification.nativeVerified,
+                        pixelsMatch: verification.pixelsMatch,
+                        problems: verification.problems,
+                    };
+                    const receipt = JSON.stringify({
+                        ...finalResult,
+                        nodeMap: verification.nodeMap,
+                        sourceEvidence: payload.sources.map(({ inspection: _inspection, ...source }) => source),
+                        targetEvidence: targets.map(({ inspection: _inspection, ...target }) => target),
+                    }, null, 2);
+                    const receiptFile = await artifactPath(root, finalResult.receiptPath, true);
+                    if (options.redact && options.redact(receipt) !== receipt) {
+                        throw new Error("Copy receipt requires credential redaction");
+                    }
+                    await atomicWriteFile(receiptFile, `${receipt}\n`, {
+                        replace: true,
+                    });
+                    receiptPersisted = true;
+                    return verification.nativeVerified && verification.pixelsMatch;
+                },
+            });
+        }
+        catch (error) {
+            if (finalResult?.status === "incomplete" &&
+                receiptPersisted &&
+                error instanceof JournalRunError &&
+                error.outcome === "failed") {
+                return finalResult;
+            }
+            throw error;
+        }
+        if (!finalResult) {
+            throw new Error("Native copy final verification did not run");
+        }
+        return finalResult;
+    });
+}

package/dist/design-releases/index.d.ts

@@ -6,3 +6,4 @@ export { finalizeRelease } from "./finalize.js";
 export { checkRelease } from "./check.js";
 export { releaseContext } from "./context.js";
 export { validateDesignRelease, validateReleasePlan, hashDesignRelease, hashDesignRelease as releaseDesignHash, } from "./validation.js";
+export * from "./copy.js";

package/dist/design-releases/index.js

@@ -5,3 +5,4 @@ export { finalizeRelease } from "./finalize.js";
 export { checkRelease } from "./check.js";
 export { releaseContext } from "./context.js";
 export { validateDesignRelease, validateReleasePlan, hashDesignRelease, hashDesignRelease as releaseDesignHash, } from "./validation.js";
+export * from "./copy.js";

package/dist/mcp-server.js

@@ -13,9 +13,9 @@ const string = {
     minLength: 1,
     maxLength: 1000,
 };
-const integer = (max) => ({
+const integer = (max, min = 0) => ({
     type: "integer",
-    minimum: 0,
+    minimum: min,
     maximum: max,
 });
 const definitions = [
@@ -247,6 +247,83 @@ const definitions = [
         ],
         localWrite: true,
     },
+    {
+        name: "design_release_copy",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        description: "Experimental same-file native board copy to release/<version>, preview by default. Requires a configured project, pinned file and connected Penpot plugin; advertised only with --allow-writes. Applying also requires an already enabled loopback browser debugging port, existing clipboard read/write access and focused editor canvas. Does not start a browser or grant permissions. Host-independent CLI/MCP operation; no automatic fallback to the assistant's computer-control tools. The successful native-UI trial used an injected test driver; bundled CDP/Penpot qualification remains pending. Preserves originals, changes focus/clipboard, never blindly replays an uncertain paste and does not approve a release.",
+        properties: {
+            sourcePage: {
+                ...string,
+                description: "Exact source page name or ID within the project's pinned Penpot file.",
+            },
+            frameIds: {
+                type: "array",
+                items: string,
+                minItems: 1,
+                maxItems: 100,
+                uniqueItems: true,
+                description: "Observed native board IDs on the source page; selections must not overlap.",
+            },
+            releaseVersion: {
+                ...string,
+                pattern: "^\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?$",
+                description: "Version naming the new or existing destination page: release/<version>.",
+            },
+            debugPort: {
+                ...integer(65535, 1),
+                description: "Required for apply: an existing loopback CDP port. This does not enable debugging or grant clipboard access.",
+            },
+            apply: {
+                type: "boolean",
+                default: false,
+                description: "False previews only. True explicitly authorizes native copying and requires debugPort plus existing browser clipboard read/write access.",
+            },
+            resume: {
+                ...string,
+                description: "Original run ID for explicit reconciliation with apply=true and the same inputs; never blindly repeats a paste.",
+            },
+        },
+        required: [
+            "sourcePage",
+            "frameIds",
+            "releaseVersion",
+        ],
+        write: true,
+        command: (a) => [
+            "design-release",
+            "copy",
+            "--source-page",
+            String(a.sourcePage),
+            ...a.frameIds.flatMap((frameId) => [
+                "--frame",
+                frameId,
+            ]),
+            "--release",
+            String(a.releaseVersion),
+            ...(a.debugPort !== undefined
+                ? [
+                    "--debug-port",
+                    String(a.debugPort),
+                ]
+                : []),
+            ...(a.apply
+                ? [
+                    "--apply",
+                ]
+                : []),
+            ...(a.resume
+                ? [
+                    "--resume",
+                    String(a.resume),
+                ]
+                : []),
+        ],
+    },
     {
         name: "run_registered",
         annotations: {
@@ -329,6 +406,7 @@ function validate(def, raw) {
                 !value ||
                 value.startsWith("-") ||
                 value.length > (schema.maxLength ?? 1000) ||
+                (schema.pattern !== undefined && !new RegExp(schema.pattern).test(value)) ||
                 /[\x00-\x1f]/.test(value))) {
             throw new Error(`Invalid ${key}`);
         }
@@ -336,7 +414,22 @@ function validate(def, raw) {
             throw new Error(`Invalid ${key}`);
         }
         if (schema.type === "integer" &&
-            (!Number.isInteger(value) || Number(value) < 0 || Number(value) > schema.maximum)) {
+            (!Number.isInteger(value) ||
+                Number(value) < (schema.minimum ?? 0) ||
+                Number(value) > schema.maximum)) {
+            throw new Error(`Invalid ${key}`);
+        }
+        if (schema.type === "array" &&
+            (!Array.isArray(value) ||
+                value.length < (schema.minItems ?? 0) ||
+                value.length > (schema.maxItems ?? 100) ||
+                (schema.uniqueItems && new Set(value).size !== value.length) ||
+                value.some((item) => schema.items?.type !== "string" ||
+                    typeof item !== "string" ||
+                    !item.trim() ||
+                    item.startsWith("-") ||
+                    item.length > (schema.items.maxLength ?? 1000) ||
+                    /[\x00-\x1f]/.test(item)))) {
             throw new Error(`Invalid ${key}`);
         }
         if (key === "params" &&
@@ -351,6 +444,9 @@ function validate(def, raw) {
     if ((a.resume || a.checkpoint) && !a.apply) {
         throw new Error("Explicit resume requires apply");
     }
+    if (def.name === "design_release_copy" && a.apply && a.debugPort === undefined) {
+        throw new Error("Native copy apply requires debugPort");
+    }
     return a;
 }
 /** Long-lived server with an immutable explicit root and no process.chdir or raw-code tool. */

package/dist/native-editor-clipboard.d.ts

@@ -0,0 +1,17 @@
+import { type BrowserTargetOptions } from "./browser-wake.js";
+export interface NativeClipboard {
+    copy(expectedPageId: string, expectedFrameIds: string[]): Promise<void>;
+    paste(expectedPageId: string): Promise<void>;
+    close(): Promise<void>;
+}
+export interface ClipboardSocket extends EventTarget {
+    readyState: number;
+    send(data: string): void;
+    close(): void;
+}
+export interface NativeClipboardOptions extends BrowserTargetOptions {
+    /** Tests may substitute the protocol transport; ordinary commands use Node's WebSocket. */
+    createSocket?: (url: string) => ClipboardSocket;
+}
+/** Holds a short exclusive clipboard session; closing releases control, never the browser. */
+export declare function connectNativeClipboard(options: NativeClipboardOptions): Promise<NativeClipboard>;