@penpair/core 0.4.0 → 0.5.0

package/dist/adapters.d.ts

@@ -51,7 +51,7 @@ export interface Adapter {
 /** Declares an adapter. Returns the definition unchanged, so a module can `export default defineAdapter({...})` with types checked. */
 export declare const defineAdapter: <T extends Adapter>(adapter: T) => T;
 /** The commands of the core itself; an adapter cannot take one of these names. */
-export declare const reservedCommands: readonly ["journey-map", "integration-map", "design-release", "formats", "snapshot", "approve", "mcp", "spec", "inspect", "probe", "pages", "tree", "audit", "tokens", "export", "shots", "archive", "snippets", "run", "run-file", "kit", "recipes", "skills", "init", "setup", "connect", "up", "down", "open", "status", "doctor", "backup", "restore", "baselines", "config", "runs", "onboard", "help"];
+export declare const reservedCommands: readonly ["journey-map", "integration-map", "design-release", "formats", "snapshot", "approve", "mcp", "spec", "inspect", "probe", "pages", "tree", "audit", "tokens", "export", "shots", "archive", "snippets", "run", "run-file", "kit", "recipes", "skills", "init", "setup", "connect", "up", "down", "open", "status", "doctor", "wake", "backup", "restore", "baselines", "config", "runs", "onboard", "help"];
 export interface LoadedAdapters {
     adapters: Adapter[];
     problems: string[];

package/dist/adapters.js

@@ -38,6 +38,7 @@ export const reservedCommands = [
     "open",
     "status",
     "doctor",
+    "wake",
     "backup",
     "restore",
     "baselines",

package/dist/browser-wake.d.ts

@@ -0,0 +1,22 @@
+export interface BrowserTargetOptions {
+    origin: string;
+    fileId: string;
+    port: number;
+    timeoutMs?: number;
+    allowLoopbackAlias?: boolean;
+    signal?: AbortSignal;
+    fetch?: typeof fetch;
+}
+export interface BrowserWakeResult {
+    activated: true;
+    targetId: string;
+    keepAlive: "none";
+}
+export interface BrowserInspectionResult {
+    targetId: string;
+    keepAlive: "unknown";
+}
+/** Activate only the existing page for the pinned file; never reload or evaluate page code. */
+export declare function wakeBrowserTarget(options: BrowserTargetOptions): Promise<BrowserWakeResult>;
+/** Read debugging metadata only; a listed tab does not establish plugin readiness or keep-alive. */
+export declare function inspectBrowserTarget(options: BrowserTargetOptions): Promise<BrowserInspectionResult>;

package/dist/browser-wake.js

@@ -0,0 +1,241 @@
+const maxTargetBytes = 1024 * 1024;
+const maxTargetCount = 1000;
+/** Activate only the existing page for the pinned file; never reload or evaluate page code. */
+export async function wakeBrowserTarget(options) {
+    return withBrowserDeadline(options, async (request) => {
+        const targetId = await findBrowserTarget(request);
+        const response = await browserRequest(request, `/json/activate/${encodeURIComponent(targetId)}`);
+        void response.body?.cancel().catch(() => undefined);
+        request.signal.throwIfAborted();
+        return {
+            activated: true,
+            targetId,
+            keepAlive: "none",
+        };
+    });
+}
+/** Read debugging metadata only; a listed tab does not establish plugin readiness or keep-alive. */
+export async function inspectBrowserTarget(options) {
+    return withBrowserDeadline(options, async (request) => ({
+        targetId: await findBrowserTarget(request),
+        keepAlive: "unknown",
+    }));
+}
+async function withBrowserDeadline(options, work) {
+    const origin = validateBrowserOptions(options);
+    if (options.signal?.aborted) {
+        throw new Error("Browser debugging cancelled");
+    }
+    const controller = new AbortController();
+    const timeoutMs = options.timeoutMs ?? 5000;
+    let timedOut = false;
+    const externalAbort = () => controller.abort();
+    const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+    }, timeoutMs);
+    options.signal?.addEventListener("abort", externalAbort, {
+        once: true,
+    });
+    let abort = () => undefined;
+    const interrupted = new Promise((_resolve, reject) => {
+        abort = () => reject(new Error(timedOut ? "Browser debugging deadline exceeded" : "Browser debugging cancelled"));
+        controller.signal.addEventListener("abort", abort, {
+            once: true,
+        });
+    });
+    try {
+        if (options.signal?.aborted) {
+            controller.abort();
+        }
+        controller.signal.throwIfAborted();
+        return await Promise.race([
+            interrupted,
+            work({
+                origin,
+                fileId: options.fileId,
+                allowLoopbackAlias: options.allowLoopbackAlias === true,
+                endpoint: `http://127.0.0.1:${options.port}`,
+                fetch: options.fetch ?? fetch,
+                signal: controller.signal,
+            }),
+        ]);
+    }
+    catch (error) {
+        if (controller.signal.aborted) {
+            throw new Error(timedOut ? "Browser debugging deadline exceeded" : "Browser debugging cancelled");
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", externalAbort);
+        controller.signal.removeEventListener("abort", abort);
+    }
+}
+function validateBrowserOptions(options) {
+    if (!Number.isInteger(options.port) || options.port < 1 || options.port > 65535) {
+        throw new Error("Browser debugging port must be an integer from 1 to 65535");
+    }
+    const timeoutMs = options.timeoutMs ?? 5000;
+    if (!Number.isInteger(timeoutMs) || timeoutMs < 1000 || timeoutMs > 30000) {
+        throw new Error("Browser debugging timeout must be an integer from 1000 to 30000 ms");
+    }
+    if (typeof options.fileId !== "string" ||
+        !options.fileId.trim() ||
+        options.fileId.length > 256 ||
+        /[\u0000-\u0020\u007f]/.test(options.fileId)) {
+        throw new Error("Browser activation requires a pinned file ID");
+    }
+    let origin;
+    try {
+        origin = new URL(options.origin);
+    }
+    catch {
+        throw new Error("Browser activation requires a valid Penpot origin");
+    }
+    if (![
+        "http:",
+        "https:",
+    ].includes(origin.protocol) ||
+        origin.username ||
+        origin.password ||
+        origin.pathname !== "/" ||
+        origin.search ||
+        origin.hash) {
+        throw new Error("Browser activation requires a Penpot origin without credentials, path or query");
+    }
+    if (options.allowLoopbackAlias && !isHttpLoopback(origin)) {
+        throw new Error("Browser loopback aliases require an HTTP localhost or 127.0.0.1 origin");
+    }
+    return origin.origin;
+}
+async function browserRequest(request, path) {
+    request.signal.throwIfAborted();
+    let response;
+    try {
+        response = await request.fetch(`${request.endpoint}${path}`, {
+            method: "GET",
+            redirect: "error",
+            signal: request.signal,
+        });
+    }
+    catch {
+        throw new Error("Cannot reach the local browser debugging endpoint; start a dedicated browser with a loopback debugging port");
+    }
+    request.signal.throwIfAborted();
+    if (!response.ok || response.redirected) {
+        void response.body?.cancel().catch(() => undefined);
+        throw new Error("The local browser debugging endpoint refused the request");
+    }
+    return response;
+}
+async function findBrowserTarget(request) {
+    const response = await browserRequest(request, "/json/list");
+    const text = await readTargetList(response);
+    request.signal.throwIfAborted();
+    let targets;
+    try {
+        targets = JSON.parse(text);
+    }
+    catch {
+        throw new Error("Invalid browser debugging target list");
+    }
+    if (!Array.isArray(targets) ||
+        targets.length > maxTargetCount ||
+        !targets.every(isBrowserTarget)) {
+        throw new Error("Invalid browser debugging target list");
+    }
+    const matching = targets.filter((target) => target.type === "page" && matchesFile(target.url, request));
+    if (matching.length !== 1) {
+        throw new Error(matching.length === 0
+            ? "No browser page matches the project's Penpot origin and pinned file ID"
+            : "Multiple browser pages match the pinned file; close duplicate tabs before waking");
+    }
+    const targetId = matching[0].id;
+    if (!/^[A-Za-z0-9_-]{1,256}$/.test(targetId)) {
+        throw new Error("Invalid browser debugging target ID");
+    }
+    return targetId;
+}
+function isBrowserTarget(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const target = value;
+    return (typeof target.id === "string" &&
+        typeof target.type === "string" &&
+        typeof target.url === "string");
+}
+function isHttpLoopback(url) {
+    return url.protocol === "http:" && (url.hostname === "localhost" || url.hostname === "127.0.0.1");
+}
+function matchesOrigin(target, request) {
+    if (target.origin === request.origin) {
+        return true;
+    }
+    if (!request.allowLoopbackAlias || !isHttpLoopback(target)) {
+        return false;
+    }
+    const expected = new URL(request.origin);
+    return isHttpLoopback(expected) && target.port === expected.port;
+}
+function matchesFile(targetUrl, request) {
+    let url;
+    try {
+        url = new URL(targetUrl);
+    }
+    catch {
+        return false;
+    }
+    if (!matchesOrigin(url, request) || url.username || url.password) {
+        return false;
+    }
+    const hashRoute = url.hash.slice(1);
+    const hashQuery = hashRoute.indexOf("?");
+    const parameters = hashQuery >= 0 && hashRoute.slice(0, hashQuery) === "/workspace"
+        ? new URLSearchParams(hashRoute.slice(hashQuery + 1))
+        : url.pathname === "/workspace" && !url.hash
+            ? url.searchParams
+            : undefined;
+    const fileIds = parameters?.getAll("file-id");
+    return fileIds?.length === 1 && fileIds[0] === request.fileId;
+}
+async function readTargetList(response) {
+    const declaredBytes = Number(response.headers.get("content-length"));
+    if (declaredBytes > maxTargetBytes) {
+        void response.body?.cancel().catch(() => undefined);
+        throw new Error("Browser debugging target list exceeds the size limit");
+    }
+    if (!response.body) {
+        throw new Error("Invalid browser debugging target list");
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let bytes = 0;
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done) {
+                break;
+            }
+            bytes += next.value.byteLength;
+            if (bytes > maxTargetBytes) {
+                throw new Error("Browser debugging target list exceeds the size limit");
+            }
+            chunks.push(next.value);
+        }
+    }
+    catch (error) {
+        void reader.cancel().catch(() => undefined);
+        if (error instanceof Error &&
+            error.message === "Browser debugging target list exceeds the size limit") {
+            throw error;
+        }
+        throw new Error("Cannot read browser debugging target list");
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return Buffer.concat(chunks, bytes).toString("utf8");
+}

package/dist/cli-main.js

@@ -1,5 +1,7 @@
 import { auditDesignRules } from "./audit-rules.js";
 import { projectStatus, projectFileUrl, openProject } from "./project-status.js";
+import { wakeBrowserTarget } from "./browser-wake.js";
+import { pluginHealthFromError } from "./plugin-health.js";
 import { artifactSchemas, migrateProjectConfig } from "./formats.js";
 import { importDtcg, exportDtcg } from "./portable-tokens.js";
 import { captureStructuralSnapshot, writeStructuralSnapshot, readStructuralSnapshot, diffStructuralSnapshots, renderStructuralDiff, } from "./structure-snapshot.js";
@@ -44,7 +46,7 @@ import { askHidden, askLine, openInBrowser } from "./instance/tty.js";
 import { validateSkillAgent } from "./skill-hosts.js";
 import { loadAdapters, readRawConfig, reservedCommands, } from "./adapters.js";
 import { requireLocalProfile } from "./local-profile.js";
-import { assertEndpointIsInstance, doctorExternal, LifecycleError, } from "./instance/connection.js";
+import { assertEndpointIsInstance, doctorExternal, doctorEditor, frontendUrl, LifecycleError, } from "./instance/connection.js";
 import { nodeRunner } from "./instance/runner.js";
 import { version } from "./version.js";
 import { guardFile } from "./file-guard.js";
@@ -59,6 +61,7 @@ Design agreements and release pages:
   penpair journey-map check|render|publish|import|accept|approve|context --from FILE
   penpair integration-map check|render|publish|import|accept|approve|context --from FILE
   penpair design-release plan|assemble|verify|finalize|check|context --from FILE
+  penpair design-release copy --source-page PAGE --frame ID --release VERSION [--debug-port PORT --apply]
   (publication previews by default; --apply writes Penpot, --write records local acceptance/review)
 Start here (guided, plain language; safe to run again):
   penpair setup                                        asks where your Penpot is (web is the default), sets everything up and checks it
@@ -71,6 +74,7 @@ Connect / diagnose:
   penpair config check [--json]                        validate configuration offline
   penpair config schema                               print its JSON Schema
   penpair doctor [--json] [--timeout-ms 5000]           origin, transport, fresh editor read and file pin (1000–30000 ms)
+  penpair wake --debug-port 9222 [--json]              activate the pinned browser tab, then verify the editor; no reload or replay
   penpair status [--adapters]                          observed project health and optional companion readiness
   penpair open [--print]                              open the pinned public file URL, or print it
   penpair probe [--integrity]                          observed APIs and limits
@@ -84,7 +88,7 @@ Build:
   penpair snippets / snippets check                    list or validate configured trusted scripts
   penpair tokens add-set|set|remove|promote             inspect token edits; --apply writes once
   penpair archive --page PAGE --name Archive --keep PREFIX [--apply]
-  (run-file/export/shots accept --layout auto|native|geometry; default auto)
+  (run-file/run/archive/token edits/export/shots accept --layout auto|native|geometry, repeatable --layout-root ID, --layout-max-nodes 1..100000)
   (journaled writes accept --resume RUN_ID --apply, --checkpoint and --trace)
 Inspect / spec:
   penpair pages                                       file identity, revision and pages
@@ -235,9 +239,19 @@ async function main(argv, cli) {
             "timeout-ms": {
                 type: "string",
             },
+            "debug-port": {
+                type: "string",
+            },
             layout: {
                 type: "string",
             },
+            "layout-root": {
+                type: "string",
+                multiple: true,
+            },
+            "layout-max-nodes": {
+                type: "string",
+            },
             page: {
                 type: "string",
             },
@@ -432,6 +446,11 @@ async function main(argv, cli) {
         "max-total-bytes",
         "capture-timeout-ms",
     ];
+    const layoutFlags = [
+        "layout",
+        "layout-root",
+        "layout-max-nodes",
+    ];
     const flags = {
         formats: [
             "out",
@@ -486,6 +505,7 @@ async function main(argv, cli) {
                     "theme",
                 ]
                 : [
+                    ...layoutFlags,
                     "type",
                     "value",
                     "description",
@@ -499,16 +519,17 @@ async function main(argv, cli) {
             "page",
             "scale",
             "name",
-            "layout",
+            ...layoutFlags,
         ],
         shots: [
             "page",
             "prefix",
             "out",
             "scale",
-            "layout",
+            ...layoutFlags,
         ],
         archive: [
+            ...layoutFlags,
             "page",
             "name",
             "keep",
@@ -527,7 +548,7 @@ async function main(argv, cli) {
             "include",
         ],
         "run-file": [
-            "layout",
+            ...layoutFlags,
             "include",
             "inspect",
             "readback",
@@ -540,6 +561,7 @@ async function main(argv, cli) {
             "trace",
         ],
         run: [
+            ...layoutFlags,
             "builtins-only",
             "param",
             "apply",
@@ -594,6 +616,10 @@ async function main(argv, cli) {
         doctor: [
             "timeout-ms",
         ],
+        wake: [
+            "debug-port",
+            "timeout-ms",
+        ],
         up: [],
         down: [],
         open: [
@@ -710,12 +736,31 @@ async function main(argv, cli) {
         ].includes(values.layout)) {
         throw new CommandArgumentError("--layout must be auto, native or geometry");
     }
-    if (command === "doctor" &&
+    if (values["layout-max-nodes"] !== undefined &&
+        (!/^\d+$/.test(values["layout-max-nodes"]) ||
+            Number(values["layout-max-nodes"]) < 1 ||
+            Number(values["layout-max-nodes"]) > 100000)) {
+        throw new CommandArgumentError("--layout-max-nodes must be an integer from 1 to 100000");
+    }
+    if (values["layout-root"] &&
+        (values["layout-root"].some((id) => !id.trim()) ||
+            new Set(values["layout-root"]).size !== values["layout-root"].length)) {
+        throw new CommandArgumentError("--layout-root must name distinct nonempty shape IDs");
+    }
+    if ((command === "doctor" || command === "wake") &&
         values["timeout-ms"] !== undefined &&
         (!/^\d+$/.test(values["timeout-ms"]) ||
             Number(values["timeout-ms"]) < 1000 ||
             Number(values["timeout-ms"]) > 30000)) {
-        throw new CommandArgumentError("doctor --timeout-ms must be an integer from 1000 to 30000");
+        throw new CommandArgumentError(`${command} --timeout-ms must be an integer from 1000 to 30000`);
+    }
+    if (command === "wake" &&
+        (rest.length ||
+            !values["debug-port"] ||
+            !/^\d+$/.test(values["debug-port"]) ||
+            Number(values["debug-port"]) < 1 ||
+            Number(values["debug-port"]) > 65535)) {
+        throw new CommandArgumentError("wake requires --debug-port with an integer from 1 to 65535");
     }
     let tokenEdit;
     if (command === "tokens" &&
@@ -1358,7 +1403,11 @@ async function main(argv, cli) {
                     {
                         check: "editor and plugin",
                         ok: false,
-                        detail: "No resolved project credential/connection; editor identity was not observed",
+                        detail: "No resolved project credential/connection; editor identity was not observed; heartbeat age unavailable; keep-alive unknown",
+                        evidence: {
+                            heartbeat: "unknown",
+                            pluginHealth: pluginHealthFromError(undefined),
+                        },
                         remedy: "Configure the private credential source, connect the intended editor, then rerun doctor.",
                     },
                 ]
@@ -1392,6 +1441,57 @@ async function main(argv, cli) {
         }
         return ok ? 0 : 1;
     }
+    if (command === "wake") {
+        const config = await loadCommandConfig(root);
+        if (!config.file?.id) {
+            throw new CommandArgumentError("Pin the owner-confirmed file before waking its browser tab");
+        }
+        const mcp = await mcpProbeFor();
+        if (!mcp) {
+            throw new Error("Configure the project's MCP connection before waking and verifying its tab");
+        }
+        assertEndpointIsInstance({
+            origin: mcp.origin,
+            source: "project connection",
+        }, config);
+        const timeoutMs = Number(values["timeout-ms"] ?? 5000);
+        const started = Date.now();
+        const activation = await wakeBrowserTarget({
+            origin: isExternal(config) ? config.profile.origin : frontendUrl(config),
+            allowLoopbackAlias: !isExternal(config),
+            fileId: config.file.id,
+            port: Number(values["debug-port"]),
+            timeoutMs,
+            signal: commandSignal(),
+        });
+        const remaining = timeoutMs - (Date.now() - started);
+        const checks = remaining > 0
+            ? await doctorEditor(config, {
+                mcp,
+                timeoutMs: remaining,
+            })
+            : [
+                {
+                    check: "editor and plugin",
+                    ok: false,
+                    detail: "Tab activation exhausted the verification deadline",
+                },
+            ];
+        const ready = checks.length > 0 && checks.every((check) => check.ok);
+        output.result({
+            ...activation,
+            ready,
+            checks,
+        });
+        if (!values.json) {
+            output.log("Browser activation acknowledged; sustained keep-alive: none. No write was replayed.");
+            for (const check of checks) {
+                output.log(`${check.ok ? "ok  " : "FAIL"} ${check.check}: ${check.detail}`);
+            }
+            output.log("Reconcile any uncertain run independently before explicitly resuming it.");
+        }
+        return ready ? 0 : 1;
+    }
     if (command === "open") {
         if (rest.length) {
             throw new CommandArgumentError("open accepts only --print for a URL preview");
@@ -1683,10 +1783,24 @@ async function main(argv, cli) {
     const client = await guarded();
     commandRedactor(endpointRedactor(endpoint));
     const options = {
-        ...(values.layout
+        ...(values.layout || values["layout-root"] || values["layout-max-nodes"]
             ? {
                 layout: {
-                    strategy: values.layout,
+                    ...(values.layout
+                        ? {
+                            strategy: values.layout,
+                        }
+                        : {}),
+                    ...(values["layout-root"]
+                        ? {
+                            shapeIds: values["layout-root"],
+                        }
+                        : {}),
+                    ...(values["layout-max-nodes"]
+                        ? {
+                            maxNodes: Number(values["layout-max-nodes"]),
+                        }
+                        : {}),
                 },
             }
             : {}),
@@ -2183,9 +2297,19 @@ async function runCliInternal(argv, options = {}) {
             argv[0] === "integration-map" ||
             argv[0] === "design-release") {
             const { runDesignCommand } = await import("./design-commands/index.js");
+            const copyConfig = argv[0] === "design-release" && argv[1] === "copy"
+                ? await loadCommandConfig(root)
+                : undefined;
             let designRedactor = (text) => redactEndpoint(text);
             return await runDesignCommand(argv[0], argv.slice(1), {
                 root,
+                copyTarget: copyConfig?.file?.id
+                    ? {
+                        fileId: copyConfig.file.id,
+                        origin: isExternal(copyConfig) ? copyConfig.profile.origin : frontendUrl(copyConfig),
+                        allowLoopbackAlias: !isExternal(copyConfig),
+                    }
+                    : undefined,
                 output,
                 redact: (text) => designRedactor(text),
                 async withPenpot(work) {
@@ -2391,15 +2515,16 @@ async function runCliBound(argv, options = {}) {
         ...argv,
     ];
     const timeoutAt = args.indexOf("--timeout-ms");
+    const boundedDiagnosis = args[0] === "doctor" || args[0] === "wake";
     let invalidTimeout = false;
     if (timeoutAt !== -1) {
         const milliseconds = Number(args[timeoutAt + 1]);
         invalidTimeout =
             !Number.isInteger(milliseconds) ||
-                milliseconds < (args[0] === "doctor" ? 1000 : 1) ||
-                milliseconds > (args[0] === "doctor" ? 30000 : 1_800_000) ||
+                milliseconds < (boundedDiagnosis ? 1000 : 1) ||
+                milliseconds > (boundedDiagnosis ? 30000 : 1_800_000) ||
                 args.indexOf("--timeout-ms", timeoutAt + 1) !== -1;
-        if (args[0] !== "doctor") {
+        if (!boundedDiagnosis) {
             args.splice(timeoutAt, 2);
         }
         if (!invalidTimeout) {
@@ -2426,8 +2551,8 @@ async function runCliBound(argv, options = {}) {
     try {
         if (invalidTimeout) {
             const result = await collectCommand(args[0] ?? "help", async () => {
-                throw new Error(args[0] === "doctor"
-                    ? "doctor --timeout-ms must be one integer from 1000 to 30000"
+                throw new Error(boundedDiagnosis
+                    ? `${args[0]} --timeout-ms must be one integer from 1000 to 30000`
                     : "--timeout-ms must be one integer from 1 to 1800000");
             });
             if (json) {

package/dist/clipboard-payload.d.ts

@@ -0,0 +1,2 @@
+/** A bounded identity check, evaluated inside the browser; clipboard text never leaves that page. */
+export declare function nativeClipboardPayloadMatches(text: string, fileId: string, frameIds: string[]): boolean;

package/dist/clipboard-payload.js

@@ -0,0 +1,89 @@
+/** A bounded identity check, evaluated inside the browser; clipboard text never leaves that page. */
+export function nativeClipboardPayloadMatches(text, fileId, frameIds) {
+    const uuid = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i;
+    const identity = (value) => {
+        if (typeof value !== "string") {
+            return undefined;
+        }
+        const plain = value.startsWith("~u") ? value.slice(2) : value;
+        return uuid.test(plain) ? plain.toLowerCase() : undefined;
+    };
+    const field = (record, name) => {
+        const ordinary = Object.hasOwn(record, name);
+        const encoded = Object.hasOwn(record, `~:${name}`);
+        return ordinary === encoded ? undefined : record[ordinary ? name : `~:${name}`];
+    };
+    const object = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+    if (typeof text !== "string" ||
+        text.length > 16 * 1024 * 1024 ||
+        !uuid.test(fileId) ||
+        !Array.isArray(frameIds) ||
+        !frameIds.length ||
+        frameIds.length > 100 ||
+        frameIds.some((id) => typeof id !== "string" || !uuid.test(id)) ||
+        new Set(frameIds.map((id) => id.toLowerCase())).size !== frameIds.length) {
+        return false;
+    }
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch {
+        return false;
+    }
+    if (!object(raw)) {
+        return false;
+    }
+    const type = field(raw, "type");
+    if ((type !== "copied-shapes" && type !== "~:copied-shapes") ||
+        identity(field(raw, "file-id")) !== fileId.toLowerCase()) {
+        return false;
+    }
+    let selected = field(raw, "selected");
+    if (object(selected)) {
+        const tags = Object.keys(selected);
+        if (tags.length !== 1 ||
+            ![
+                "~#set",
+                "~#ordered-set",
+            ].includes(tags[0])) {
+            return false;
+        }
+        selected = selected[tags[0]];
+    }
+    else if (Array.isArray(selected) &&
+        selected.length === 2 &&
+        typeof selected[0] === "string" &&
+        [
+            "~#set",
+            "~#ordered-set",
+        ].includes(selected[0])) {
+        selected = selected[1];
+    }
+    if (!Array.isArray(selected) || selected.length !== frameIds.length) {
+        return false;
+    }
+    const selectedIds = selected.map(identity);
+    if (selectedIds.some((id) => !id) ||
+        new Set(selectedIds).size !== frameIds.length ||
+        frameIds.some((id) => !selectedIds.includes(id.toLowerCase()))) {
+        return false;
+    }
+    const objects = field(raw, "objects");
+    if (!object(objects)) {
+        return false;
+    }
+    const entries = Object.entries(objects);
+    if (entries.length > 20000 || entries.length < frameIds.length) {
+        return false;
+    }
+    const objectIds = new Set();
+    for (const [key, value] of entries) {
+        const id = identity(key);
+        if (!id || objectIds.has(id) || !object(value) || identity(field(value, "id")) !== id) {
+            return false;
+        }
+        objectIds.add(id);
+    }
+    return frameIds.every((id) => objectIds.has(id.toLowerCase()));
+}