openplanr 2.2640.8 → 2.2640.9

package/lib/host-packages/claude/openplanr/runtime/design/scripts/design-share.mjs

@@ -6,21 +6,31 @@ import {
   currentDesign,
   hash,
   readJson
-} from "./design-escape.mjs";
+} from "./design-shared-artifact-support-dependencies-design-support-protocol-contracts-3d9b1a86.mjs";
+import {
+  createEncryptedWorkspaceClient,
+  createWorkspaceAddress
+} from "./design-encrypted-workspace-client.mjs";
 import {
   copyUploadSpool,
-  createChunkedWorkspaceClient,
-  ensurePrivateDirectory,
   persistUploadSpool,
+  spoolChunkReader
+} from "./design-upload-spool.mjs";
+import {
+  createChunkedWorkspaceClient
+} from "./design-chunked-workspace-client.mjs";
+import {
+  ensurePrivateDirectory,
   readCustody,
-  spoolChunkReader,
   writeCustody
-} from "./design-pako-esm.mjs";
+} from "./design-owner-custody.mjs";
 import {
-  acquireStartLock,
   configuredPlanrHome,
   planrHome
-} from "./design-planr-home.mjs";
+} from "./design-runtime-home.mjs";
+import {
+  acquireStartLock
+} from "./design-loopback-server.mjs";
 import {
   ARTIFACT_ERROR_CODES,
   PipelineError,
@@ -28,7 +38,7 @@ import {
   digestArtifactEnvelope,
   validateArtifactEnvelope,
   validateArtifactReview
-} from "./design-artifact-sources.mjs";
+} from "./design-shared-artifact-support-protocol-contracts-ea2cd15e.mjs";
 import {
   DESIGN_WORKSPACE_API,
   DESIGN_WORKSPACE_CREATE_SCHEMA,
@@ -38,11 +48,93 @@ import {
   DESIGN_WORKSPACE_REVISION_SCHEMA,
   DESIGN_WORKSPACE_SCHEMA,
   DESIGN_WORKSPACE_VERSION,
-  assertWorkspaceContract,
+  assertWorkspaceContract
+} from "./design-shared-protocol-contracts-31a760fc.mjs";
+import {
   canonicalizeJson,
   deepFreeze,
   sha256Hex
-} from "./design-bounded-json-data.mjs";
+} from "./design-shared-protocol-contracts-75a938cc.mjs";
+
+// packages/design/lib/design/share-status.mjs
+import { existsSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+
+// packages/design/lib/design/workspace-address.mjs
+var DESIGN_SHARE_BASE_URL = "https://share.openplanr.dev";
+var DESIGN_SHARE_REVIEW_PATH = "/d";
+var address = createWorkspaceAddress({
+  label: "Design",
+  reviewPath: DESIGN_SHARE_REVIEW_PATH,
+  defaultBaseUrl: DESIGN_SHARE_BASE_URL
+});
+var normalizeWorkspaceBase = address.normalizeWorkspaceBase;
+var workspaceReviewUrl = (access) => `${address.workspaceReviewUrl(access)}${access.schemaVersion === "2.0.0" ? "?v=2" : ""}`;
+
+// packages/design/lib/design/share-status.mjs
+var FORMAT = "openplanr-design-owner-custody";
+function custodyLocation(file, options = {}, { allowMissing = false } = {}) {
+  const current = currentDesign(file, options);
+  const env = options.env ?? process.env;
+  const root = resolve(options.custodyRoot ?? join(planrHome(env), "design-shares"));
+  let project = current.root;
+  for (let candidate = current.root; dirname(candidate) !== candidate; candidate = dirname(candidate)) {
+    if (existsSync(join(candidate, ".git")) || existsSync(join(candidate, ".planr"))) {
+      project = candidate;
+      break;
+    }
+  }
+  const key = hash(`${current.root}
+${current.document.id}`);
+  const path = join(root, `${key}.json`);
+  const within = relative(project, root);
+  if ((!allowMissing || existsSync(path)) && (within === "" || !within.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) && within !== ".." && !isAbsolute(within)))
+    throw new Error(
+      "Design owner credentials must be stored outside the project. Set PLANR_HOME to a private user-level directory."
+    );
+  const legacyPath = !options.custodyRoot && !configuredPlanrHome(env) ? join(realpathSync(env.HOME || homedir()), ".openplanr", "design-shares", `${key}.json`) : null;
+  return { root, path, current, legacyPath };
+}
+function presentationFingerprint(current) {
+  const state = readJson(join(current.root, ".design/studio-state.json"), { state: {} }).state;
+  return hash(
+    JSON.stringify({
+      revision: current.revision,
+      selectedVariant: state.selectedVariant ?? current.document.selectedVariant,
+      positions: state.positions ?? {},
+      verification: current.verification.status
+    })
+  );
+}
+var safeStatus = (record, current) => ({
+  ok: true,
+  shared: Boolean(record),
+  title: current.document.title,
+  localRevision: current.revision,
+  retention: "until-revoked",
+  ...record ? {
+    id: record.custody.id,
+    url: workspaceReviewUrl(record.custody),
+    revision: record.custody.currentRevision ?? record.publishedRevision ?? null,
+    publishedRevision: record.publishedRevision ?? null,
+    hasUpdate: record.publishedRevision !== current.revision || record.publishedPresentation !== presentationFingerprint(current),
+    epoch: record.custody.epoch,
+    commentsPaused: Boolean(record.custody.commentsPaused ?? record.commentsPaused),
+    revoked: Boolean(record.revoked),
+    deleted: Boolean(record.deleted),
+    pending: Boolean(
+      record.custody.pendingCreate || record.custody.pendingMutation || record.pendingReviewMetadata?.length
+    ),
+    pendingAction: record.custody.pendingCreate ? "create" : record.custody.pendingMutation?.action ?? (record.pendingReviewMetadata?.length ? "review-metadata" : null),
+    pendingReviewMetadata: Boolean(record.pendingReviewMetadata?.length)
+  } : {}
+});
+function getDesignShareStatus(file, options = {}) {
+  const { path, current, legacyPath } = custodyLocation(file, options);
+  const record = readCustody(path, { label: "Design", format: FORMAT }) ?? (legacyPath ? readCustody(legacyPath, { label: "Design", format: FORMAT }) : null);
+  return safeStatus(record, current);
+}
 
 // packages/design/lib/design/share.mjs
 import {
@@ -59,18 +151,18 @@ import { basename, dirname as dirname4, join as join3, resolve as resolve3 } fro
 
 // packages/artifact/lib/artifact/import.mjs
 import {
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync2,
-  realpathSync,
+  realpathSync as realpathSync2,
   renameSync as renameSync2,
   rmSync as rmSync2,
   statSync as statSync2,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import { homedir } from "node:os";
-import { dirname as dirname2, isAbsolute, join, relative, resolve } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve as resolve2 } from "node:path";
 
 // packages/artifact/lib/artifact/internal/feedback.mjs
 var FEEDBACK_FILE = "feedback.json";
@@ -308,7 +400,7 @@ function effectiveReviewDecision(value) {
 // packages/artifact/lib/artifact/review.mjs
 import { randomBytes, randomUUID } from "node:crypto";
 import {
-  existsSync,
+  existsSync as existsSync2,
   lstatSync,
   mkdirSync,
   readFileSync,
@@ -317,7 +409,7 @@ import {
   statSync,
   writeFileSync
 } from "node:fs";
-import { dirname } from "node:path";
+import { dirname as dirname2 } from "node:path";
 var ARTIFACT_REVIEW_MAX_STATE_BYTES = 5 * 1024 * 1024;
 var reviewPathQueues = /* @__PURE__ */ new Map();
 function finalEntry(path, fs = { lstatSync }) {
@@ -412,7 +504,7 @@ function readArtifactReviewState(path, { allowMissing = false } = {}) {
 }
 function writeArtifactReviewState(path, ledger, { fileSystem = {}, suffix = `${process.pid}.${randomBytes(8).toString("hex")}` } = {}) {
   validateReviewLedger(ledger);
-  const fs = { existsSync, lstatSync, mkdirSync, writeFileSync, renameSync, rmSync, ...fileSystem };
+  const fs = { existsSync: existsSync2, lstatSync, mkdirSync, writeFileSync, renameSync, rmSync, ...fileSystem };
   const temporary = `${path}.${suffix}.tmp`;
   const serialized = serializeReviewState(ledger);
   if (Buffer.byteLength(serialized, "utf8") > ARTIFACT_REVIEW_MAX_STATE_BYTES) {
@@ -427,7 +519,7 @@ function writeArtifactReviewState(path, ledger, { fileSystem = {}, suffix = `${p
       const target = initial;
       if (target.isSymbolicLink() || !target.isFile()) throw new Error("unsafe final target");
     }
-    fs.mkdirSync(dirname(path), { recursive: true, mode: 448 });
+    fs.mkdirSync(dirname2(path), { recursive: true, mode: 448 });
     fs.writeFileSync(temporary, serialized, { mode: 384, flag: "wx" });
     const final = finalEntry(path, fs);
     if (final) {
@@ -588,12 +680,12 @@ function pathEntry(path, fs = { lstatSync: lstatSync2 }) {
   }
 }
 function inside(base, candidate) {
-  const rel = relative(base, candidate);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+  const rel = relative2(base, candidate);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
 }
 function parseablePlanrConfig(root) {
-  const path = join(root, ".planr", "config.json");
-  if (!existsSync2(path)) return false;
+  const path = join2(root, ".planr", "config.json");
+  if (!existsSync3(path)) return false;
   try {
     if (lstatSync2(path).isSymbolicLink()) return false;
     const value = JSON.parse(readFileSync2(path, "utf8"));
@@ -603,20 +695,20 @@ function parseablePlanrConfig(root) {
   }
 }
 function hasGitMarker(root) {
-  const marker = join(root, ".git");
-  if (!existsSync2(marker)) return false;
+  const marker = join2(root, ".git");
+  if (!existsSync3(marker)) return false;
   try {
     const stat = lstatSync2(marker);
     if (stat.isSymbolicLink()) return false;
     if (stat.isDirectory()) {
-      const head = join(marker, "HEAD");
-      return existsSync2(head) && lstatSync2(head).isFile();
+      const head = join2(marker, "HEAD");
+      return existsSync3(head) && lstatSync2(head).isFile();
     }
     if (!stat.isFile() || stat.size > 4096) return false;
     const match = /^gitdir:\s*(.+?)\s*$/u.exec(readFileSync2(marker, "utf8"));
     if (!match) return false;
-    const gitDir = resolve(root, match[1]);
-    return existsSync2(gitDir) && statSync2(gitDir).isDirectory() && existsSync2(join(gitDir, "HEAD")) && lstatSync2(join(gitDir, "HEAD")).isFile();
+    const gitDir = resolve2(root, match[1]);
+    return existsSync3(gitDir) && statSync2(gitDir).isDirectory() && existsSync3(join2(gitDir, "HEAD")) && lstatSync2(join2(gitDir, "HEAD")).isFile();
   } catch {
     return false;
   }
@@ -624,37 +716,37 @@ function hasGitMarker(root) {
 function findArtifactProjectRoot(start = process.cwd(), { env = process.env } = {}) {
   let current;
   try {
-    current = realpathSync(resolve(start));
+    current = realpathSync2(resolve2(start));
   } catch {
     pathError(
       ARTIFACT_ERROR_CODES.REVIEW_IMPORT,
       "Artifact review working directory does not exist."
     );
   }
-  const homeCandidate = resolve(env.HOME ?? homedir());
+  const homeCandidate = resolve2(env.HOME ?? homedir2());
   let home = homeCandidate;
   try {
-    home = realpathSync(homeCandidate);
+    home = realpathSync2(homeCandidate);
   } catch {
   }
   while (true) {
     if (current !== home && (parseablePlanrConfig(current) || hasGitMarker(current)))
       return current;
-    const parent = dirname2(current);
+    const parent = dirname3(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function assertSafeDestination(base, relativeParts) {
-  const absoluteBase = resolve(base);
-  if (existsSync2(absoluteBase) && lstatSync2(absoluteBase).isSymbolicLink()) {
+  const absoluteBase = resolve2(base);
+  if (existsSync3(absoluteBase) && lstatSync2(absoluteBase).isSymbolicLink()) {
     pathError(
       ARTIFACT_ERROR_CODES.SYMLINK_ESCAPE,
       "Artifact review destination base is a symlink."
     );
   }
   let realBase = absoluteBase;
-  if (existsSync2(absoluteBase)) realBase = realpathSync(absoluteBase);
+  if (existsSync3(absoluteBase)) realBase = realpathSync2(absoluteBase);
   let current = absoluteBase;
   for (const part of relativeParts) {
     if (!part || part === "." || part === ".." || part.includes("/") || part.includes("\\") || part.includes("\0")) {
@@ -663,7 +755,7 @@ function assertSafeDestination(base, relativeParts) {
         "Artifact review destination contains an unsafe segment."
       );
     }
-    current = join(current, part);
+    current = join2(current, part);
     const entry = pathEntry(current);
     if (!entry) continue;
     if (entry.isSymbolicLink()) {
@@ -672,7 +764,7 @@ function assertSafeDestination(base, relativeParts) {
         "Artifact review destination contains a symlink."
       );
     }
-    if (!inside(realBase, realpathSync(current))) {
+    if (!inside(realBase, realpathSync2(current))) {
       pathError(
         ARTIFACT_ERROR_CODES.PATH_TRAVERSAL,
         "Artifact review destination escapes its storage root."
@@ -700,8 +792,8 @@ function resolveArtifactReviewDestination({
     );
   }
   if (designDir !== void 0) {
-    const lexical = resolve(designDir);
-    if (!existsSync2(lexical) || !statSync2(lexical).isDirectory()) {
+    const lexical = resolve2(designDir);
+    if (!existsSync3(lexical) || !statSync2(lexical).isDirectory()) {
       pathError(ARTIFACT_ERROR_CODES.REVIEW_IMPORT, "Design review destination does not exist.");
     }
     if (lstatSync2(lexical).isSymbolicLink()) {
@@ -710,13 +802,13 @@ function resolveArtifactReviewDestination({
         "Design review destination must be a real directory."
       );
     }
-    const requested = realpathSync(lexical);
+    const requested = realpathSync2(lexical);
     return Object.freeze({
       kind: "design",
       artifactId,
       directory: requested,
-      path: join(requested, FEEDBACK_FILE),
-      reviewStatePath: join(requested, "artifact-review-state.json")
+      path: join2(requested, FEEDBACK_FILE),
+      reviewStatePath: join2(requested, "artifact-review-state.json")
     });
   }
   const projectRoot = findArtifactProjectRoot(cwd, { env });
@@ -727,17 +819,17 @@ function resolveArtifactReviewDestination({
       artifactId,
       root: projectRoot,
       directory: directory2,
-      path: join(directory2, "review-state.json")
+      path: join2(directory2, "review-state.json")
     });
   }
-  const root = resolve(planrHome(env));
+  const root = resolve2(planrHome(env));
   const directory = assertSafeDestination(root, ["artifacts", artifactId]);
   return Object.freeze({
     kind: "user",
     artifactId,
     root,
     directory,
-    path: join(directory, "review-state.json")
+    path: join2(directory, "review-state.json")
   });
 }
 function reviewsFromDecoded(value) {
@@ -820,724 +912,6 @@ async function decodeArtifactReviewSources(sources, { decodeSource, withMetadata
   return withMetadata ? entries : entries.map((entry) => entry.review);
 }
 
-// packages/design/lib/design/share-status.mjs
-import { existsSync as existsSync3, realpathSync as realpathSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname3, isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve as resolve2 } from "node:path";
-
-// packages/artifact/lib/artifact/internal/workspace-address.mjs
-function createWorkspaceAddress({
-  label,
-  reviewPath,
-  defaultBaseUrl = "https://share.openplanr.dev"
-}) {
-  function normalizeWorkspaceBase2(baseUrl = defaultBaseUrl) {
-    const url = new URL(baseUrl);
-    if (url.username || url.password || url.search || url.hash || url.pathname !== "/" || url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname)))
-      throw new TypeError(
-        `${label} sharing requires an HTTPS origin or a local development server.`
-      );
-    return url.origin;
-  }
-  function workspaceReviewUrl2(access) {
-    if (!/^[A-Za-z0-9_-]{22,64}$/.test(access.id))
-      throw new TypeError(`Invalid ${label.toLowerCase()} workspace identity.`);
-    return `${normalizeWorkspaceBase2(access.baseUrl)}${reviewPath}/${access.id}`;
-  }
-  return { normalizeWorkspaceBase: normalizeWorkspaceBase2, workspaceReviewUrl: workspaceReviewUrl2 };
-}
-
-// packages/design/lib/design/workspace-address.mjs
-var DESIGN_SHARE_BASE_URL = "https://share.openplanr.dev";
-var DESIGN_SHARE_REVIEW_PATH = "/d";
-var address = createWorkspaceAddress({
-  label: "Design",
-  reviewPath: DESIGN_SHARE_REVIEW_PATH,
-  defaultBaseUrl: DESIGN_SHARE_BASE_URL
-});
-var normalizeWorkspaceBase = address.normalizeWorkspaceBase;
-var workspaceReviewUrl = (access) => `${address.workspaceReviewUrl(access)}${access.schemaVersion === "2.0.0" ? "?v=2" : ""}`;
-
-// packages/design/lib/design/share-status.mjs
-var FORMAT = "openplanr-design-owner-custody";
-function custodyLocation(file, options = {}, { allowMissing = false } = {}) {
-  const current = currentDesign(file, options);
-  const env = options.env ?? process.env;
-  const root = resolve2(options.custodyRoot ?? join2(planrHome(env), "design-shares"));
-  let project = current.root;
-  for (let candidate = current.root; dirname3(candidate) !== candidate; candidate = dirname3(candidate)) {
-    if (existsSync3(join2(candidate, ".git")) || existsSync3(join2(candidate, ".planr"))) {
-      project = candidate;
-      break;
-    }
-  }
-  const key = hash(`${current.root}
-${current.document.id}`);
-  const path = join2(root, `${key}.json`);
-  const within = relative2(project, root);
-  if ((!allowMissing || existsSync3(path)) && (within === "" || !within.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) && within !== ".." && !isAbsolute2(within)))
-    throw new Error(
-      "Design owner credentials must be stored outside the project. Set PLANR_HOME to a private user-level directory."
-    );
-  const legacyPath = !options.custodyRoot && !configuredPlanrHome(env) ? join2(realpathSync2(env.HOME || homedir2()), ".openplanr", "design-shares", `${key}.json`) : null;
-  return { root, path, current, legacyPath };
-}
-function presentationFingerprint(current) {
-  const state = readJson(join2(current.root, ".design/studio-state.json"), { state: {} }).state;
-  return hash(
-    JSON.stringify({
-      revision: current.revision,
-      selectedVariant: state.selectedVariant ?? current.document.selectedVariant,
-      positions: state.positions ?? {},
-      verification: current.verification.status
-    })
-  );
-}
-var safeStatus = (record, current) => ({
-  ok: true,
-  shared: Boolean(record),
-  title: current.document.title,
-  localRevision: current.revision,
-  retention: "until-revoked",
-  ...record ? {
-    id: record.custody.id,
-    url: workspaceReviewUrl(record.custody),
-    revision: record.custody.currentRevision ?? record.publishedRevision ?? null,
-    publishedRevision: record.publishedRevision ?? null,
-    hasUpdate: record.publishedRevision !== current.revision || record.publishedPresentation !== presentationFingerprint(current),
-    epoch: record.custody.epoch,
-    commentsPaused: Boolean(record.custody.commentsPaused ?? record.commentsPaused),
-    revoked: Boolean(record.revoked),
-    deleted: Boolean(record.deleted),
-    pending: Boolean(
-      record.custody.pendingCreate || record.custody.pendingMutation || record.pendingReviewMetadata?.length
-    ),
-    pendingAction: record.custody.pendingCreate ? "create" : record.custody.pendingMutation?.action ?? (record.pendingReviewMetadata?.length ? "review-metadata" : null),
-    pendingReviewMetadata: Boolean(record.pendingReviewMetadata?.length)
-  } : {}
-});
-function getDesignShareStatus(file, options = {}) {
-  const { path, current, legacyPath } = custodyLocation(file, options);
-  const record = readCustody(path, { label: "Design", format: FORMAT }) ?? (legacyPath ? readCustody(legacyPath, { label: "Design", format: FORMAT }) : null);
-  return safeStatus(record, current);
-}
-
-// packages/artifact/lib/artifact/encrypted-workspace-client.mjs
-function createEncryptedWorkspaceClient({
-  domain,
-  apiPath,
-  reviewPath,
-  label,
-  compatibilityMessage,
-  compatibilityCode = "E_WORKSPACE_UNSUPPORTED",
-  defaultBaseUrl = "https://share.openplanr.dev",
-  version = "1.0.0",
-  maxBytes = 5 * 1024 * 1024,
-  maxEventBytes = 256 * 1024,
-  schemas,
-  assertContract,
-  assertBundle,
-  assertFeedback,
-  bundleDigest,
-  digestInput = (bundle) => bundle,
-  packBundle = async (bundle) => bundle,
-  unpackBundle = async (bundle) => bundle
-}) {
-  if (!domain || !apiPath?.startsWith("/") || !reviewPath?.startsWith("/") || !label)
-    throw new TypeError("An encrypted workspace requires an explicit domain and routes.");
-  const encoder2 = new TextEncoder();
-  const decoder2 = new TextDecoder("utf-8", { fatal: true });
-  const tokenPattern = /^[A-Za-z0-9_-]{43}$/;
-  const idPattern = /^[A-Za-z0-9_-]{22,64}$/;
-  const ec = { name: "ECDSA", namedCurve: "P-256" };
-  const signatureAlgorithm = { name: "ECDSA", hash: "SHA-256" };
-  const omitSignature = ({ signature: _signature, ...value }) => value;
-  const operationError = (message, code, status) => Object.assign(new Error(message), { code, ...status ? { status } : {} });
-  function encodeWorkspaceBytes2(bytes) {
-    let binary = "";
-    for (let offset = 0; offset < bytes.length; offset += 8192)
-      binary += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
-    return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
-  }
-  function decodeWorkspaceBytes2(value) {
-    if (typeof value !== "string" || !/^[A-Za-z0-9_-]+$/u.test(value))
-      throw new TypeError("Invalid encoded workspace value.");
-    const decoded = Uint8Array.from(
-      atob(value.replaceAll("-", "+").replaceAll("_", "/")),
-      (char) => char.charCodeAt(0)
-    );
-    if (encodeWorkspaceBytes2(decoded) !== value)
-      throw new TypeError("Noncanonical encoded workspace value.");
-    return decoded;
-  }
-  function newWorkspaceToken2() {
-    return encodeWorkspaceBytes2(crypto.getRandomValues(new Uint8Array(32)));
-  }
-  function newWorkspaceId2() {
-    return encodeWorkspaceBytes2(crypto.getRandomValues(new Uint8Array(18)));
-  }
-  const { normalizeWorkspaceBase: normalizeWorkspaceBase2, workspaceReviewUrl: workspaceReviewUrl2 } = createWorkspaceAddress({
-    label,
-    reviewPath,
-    defaultBaseUrl
-  });
-  async function tokenMaterial(token, id, purpose) {
-    if (!tokenPattern.test(token) || decodeWorkspaceBytes2(token).length !== 32 || !idPattern.test(id))
-      throw new TypeError("Enter the complete generated access token.");
-    const key = await crypto.subtle.importKey("raw", decodeWorkspaceBytes2(token), "HKDF", false, [
-      "deriveBits"
-    ]);
-    return new Uint8Array(
-      await crypto.subtle.deriveBits(
-        {
-          name: "HKDF",
-          hash: "SHA-256",
-          salt: encoder2.encode(id),
-          info: encoder2.encode(`${domain}/${purpose}`)
-        },
-        key,
-        256
-      )
-    );
-  }
-  async function deriveWorkspaceAuthentication2(token, id) {
-    return encodeWorkspaceBytes2(await tokenMaterial(token, id, "reviewer-auth"));
-  }
-  function canonicalWorkspacePublicKey2(value) {
-    if (value?.kty !== "EC" || value.crv !== "P-256" || !tokenPattern.test(value.x ?? "") || !tokenPattern.test(value.y ?? "") || "d" in value) {
-      throw new TypeError(`Invalid ${label.toLowerCase()} workspace public key.`);
-    }
-    return { kty: "EC", crv: "P-256", x: value.x, y: value.y };
-  }
-  async function createWorkspaceSigner2() {
-    const pair = await crypto.subtle.generateKey(ec, true, ["sign", "verify"]);
-    return {
-      privateKey: encodeWorkspaceBytes2(
-        new Uint8Array(await crypto.subtle.exportKey("pkcs8", pair.privateKey))
-      ),
-      publicKey: canonicalWorkspacePublicKey2(await crypto.subtle.exportKey("jwk", pair.publicKey))
-    };
-  }
-  async function signWorkspaceValue2(value, privateKey) {
-    const key = await crypto.subtle.importKey(
-      "pkcs8",
-      decodeWorkspaceBytes2(privateKey),
-      ec,
-      false,
-      ["sign"]
-    );
-    const signature = await crypto.subtle.sign(
-      signatureAlgorithm,
-      key,
-      encoder2.encode(canonicalizeJson(omitSignature(value)))
-    );
-    return { ...omitSignature(value), signature: encodeWorkspaceBytes2(new Uint8Array(signature)) };
-  }
-  async function verifyWorkspaceSignature2(value, publicKey) {
-    try {
-      const key = await crypto.subtle.importKey("jwk", publicKey, ec, false, ["verify"]);
-      return await crypto.subtle.verify(
-        signatureAlgorithm,
-        key,
-        decodeWorkspaceBytes2(value.signature),
-        encoder2.encode(canonicalizeJson(omitSignature(value)))
-      );
-    } catch {
-      return false;
-    }
-  }
-  async function seal(value, rawKey, context, limit = maxBytes) {
-    const bytes = encoder2.encode(canonicalizeJson(value));
-    if (bytes.length + 16 > limit)
-      throw Object.assign(
-        new RangeError(
-          `Encrypted ${label.toLowerCase()} data exceeds the ${Math.floor(limit / 1024)} KB upload limit.`
-        ),
-        { code: "E_WORKSPACE_PAYLOAD_TOO_LARGE", status: 413 }
-      );
-    const key = await crypto.subtle.importKey("raw", rawKey, "AES-GCM", false, ["encrypt"]);
-    const iv = crypto.getRandomValues(new Uint8Array(12));
-    const ciphertext = await crypto.subtle.encrypt(
-      { name: "AES-GCM", iv, additionalData: encoder2.encode(canonicalizeJson(context)) },
-      key,
-      bytes
-    );
-    return {
-      iv: encodeWorkspaceBytes2(iv),
-      ciphertext: encodeWorkspaceBytes2(new Uint8Array(ciphertext))
-    };
-  }
-  async function unseal(value, rawKey, context, limit = maxBytes) {
-    const bytes = decodeWorkspaceBytes2(value.ciphertext);
-    if (bytes.length > limit)
-      throw new RangeError(`Shared ${label.toLowerCase()} data exceeds its size limit.`);
-    const key = await crypto.subtle.importKey("raw", rawKey, "AES-GCM", false, ["decrypt"]);
-    const plaintext = await crypto.subtle.decrypt(
-      {
-        name: "AES-GCM",
-        iv: decodeWorkspaceBytes2(value.iv),
-        additionalData: encoder2.encode(canonicalizeJson(context))
-      },
-      key,
-      bytes
-    );
-    return JSON.parse(decoder2.decode(plaintext));
-  }
-  const keyringContext = (id, epoch) => ({ type: "keyring", workspaceId: id, epoch });
-  const revisionContext = (id, revision) => ({
-    type: "revision",
-    workspaceId: id,
-    id: revision.id,
-    epoch: revision.epoch,
-    reviewOf: revision.reviewOf
-  });
-  const eventContext = (id, event) => ({
-    type: "event",
-    workspaceId: id,
-    id: event.id,
-    epoch: event.epoch,
-    revisionId: event.revisionId,
-    reviewOf: event.reviewOf
-  });
-  function workspaceEnvelopeDigest2(value) {
-    return bundleDigest(value);
-  }
-  async function wrapKeyring(custody, token = custody.token, epoch = custody.epoch, keys = custody.keys) {
-    return seal(
-      { keys, ownerPublicKey: custody.ownerPublicKey },
-      await tokenMaterial(token, custody.id, "key-wrap"),
-      keyringContext(custody.id, epoch)
-    );
-  }
-  async function prepareRevision(custody, bundle) {
-    assertBundle(bundle);
-    const header = {
-      id: newWorkspaceId2(),
-      epoch: custody.epoch,
-      reviewOf: workspaceEnvelopeDigest2(digestInput(bundle)),
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    return signWorkspaceValue2(
-      {
-        ...header,
-        ...await seal(
-          await packBundle(bundle),
-          decodeWorkspaceBytes2(custody.keys[custody.epoch]),
-          revisionContext(custody.id, header)
-        )
-      },
-      custody.ownerPrivateKey
-    );
-  }
-  async function prepareWorkspace2(bundle, { baseUrl = defaultBaseUrl } = {}) {
-    const signer = await createWorkspaceSigner2();
-    const custody = {
-      schemaVersion: version,
-      id: newWorkspaceId2(),
-      baseUrl: normalizeWorkspaceBase2(baseUrl),
-      token: newWorkspaceToken2(),
-      ownerAuth: newWorkspaceToken2(),
-      ownerPrivateKey: signer.privateKey,
-      ownerPublicKey: signer.publicKey,
-      epoch: 1,
-      keys: { 1: newWorkspaceToken2() },
-      version: 0
-    };
-    custody.keyring = await wrapKeyring(custody);
-    custody.pendingCreate = await signWorkspaceValue2(
-      {
-        schemaVersion: version,
-        id: custody.id,
-        ownerPublicKey: custody.ownerPublicKey,
-        ownerAuthHash: sha256Hex(custody.ownerAuth),
-        reviewerAuthHash: sha256Hex(await deriveWorkspaceAuthentication2(custody.token, custody.id)),
-        epoch: 1,
-        keyring: custody.keyring,
-        revision: await prepareRevision(custody, bundle),
-        operationId: newWorkspaceId2()
-      },
-      custody.ownerPrivateKey
-    );
-    assertContract(custody.pendingCreate, schemas.create);
-    return custody;
-  }
-  async function request(access, suffix = "", {
-    method = "GET",
-    body,
-    fetchImpl = globalThis.fetch,
-    owner = Boolean(access.ownerAuth),
-    timeoutMs = 2e4
-  } = {}) {
-    if (!idPattern.test(access.id))
-      throw new TypeError(`Invalid ${label.toLowerCase()} workspace identity.`);
-    const authorization = owner ? access.ownerAuth : await deriveWorkspaceAuthentication2(access.token, access.id);
-    const headers = { Authorization: `Bearer ${authorization}`, Accept: "application/json" };
-    if (body) headers["Content-Type"] = "application/json";
-    let response;
-    try {
-      response = await fetchImpl(
-        `${normalizeWorkspaceBase2(access.baseUrl)}${apiPath}/${access.id}${suffix}`,
-        {
-          method,
-          headers,
-          body: body ? JSON.stringify(body) : void 0,
-          redirect: "error",
-          cache: "no-store",
-          credentials: "omit",
-          signal: AbortSignal.timeout(timeoutMs)
-        }
-      );
-    } catch {
-      throw operationError(
-        `${label} sharing is unreachable. Check the connection and retry; the previous review is unchanged.`,
-        "E_WORKSPACE_NETWORK"
-      );
-    }
-    if (!response.ok) await throwResponseError(response, method);
-    return readResponse(response);
-  }
-  async function throwResponseError(response, method) {
-    if (response.status === 404 && method === "PUT" && compatibilityMessage) {
-      const error2 = new Error(compatibilityMessage);
-      error2.code = compatibilityCode;
-      error2.status = 404;
-      throw error2;
-    }
-    const messages = {
-      401: "Access token is incorrect or has been rotated.",
-      403: "This review is unavailable or this action requires its owner.",
-      404: "This shared review could not be found.",
-      409: "The shared review changed. Refresh its status before retrying.",
-      410: "This shared review has been revoked or deleted.",
-      413: `This ${label.toLowerCase()} exceeds the sharing upload limit.`,
-      429: "Too many requests. Wait a moment and retry.",
-      503: `${label} sharing is temporarily unavailable. Retry shortly.`
-    };
-    const error = new Error(
-      messages[response.status] ?? `${label} sharing failed (${response.status}). Retry shortly.`
-    );
-    error.status = response.status;
-    error.code = `E_WORKSPACE_HTTP_${response.status}`;
-    try {
-      const reader = response.body?.getReader();
-      const body = reader && JSON.parse(decoder2.decode(await responseBytes(reader, 4096)));
-      if (typeof body?.error === "string" && /^[A-Za-z][A-Za-z0-9_-]{0,127}$/u.test(body.error))
-        error.code = body.error;
-    } catch {
-    }
-    if (response.status === 429) {
-      const header = response.headers.get("retry-after");
-      const seconds = header && /^\d+(?:\.\d+)?$/u.test(header.trim()) ? Number(header) : header ? (Date.parse(header) - Date.now()) / 1e3 : NaN;
-      if (Number.isFinite(seconds) && seconds >= 0)
-        error.retryAfterSeconds = Math.min(3600, Math.max(1, Math.ceil(seconds)));
-    }
-    throw error;
-  }
-  async function responseBytes(reader, limit) {
-    const chunks = [];
-    let length = 0;
-    try {
-      for (; ; ) {
-        const { value, done } = await reader.read();
-        if (done) break;
-        length += value.length;
-        if (length > limit) {
-          await reader.cancel();
-          throw new RangeError(`${label} service returned an oversized response.`);
-        }
-        chunks.push(value);
-      }
-    } catch (error) {
-      if (error instanceof RangeError) throw error;
-      throw new Error("The sharing response was interrupted. Retry the pending operation.");
-    }
-    const bytes = new Uint8Array(length);
-    let offset = 0;
-    for (const chunk of chunks) {
-      bytes.set(chunk, offset);
-      offset += chunk.length;
-    }
-    return bytes;
-  }
-  async function readResponse(response) {
-    if (response.status === 204) return {};
-    const reader = response.body?.getReader();
-    if (!reader) throw new Error(`${label} service returned an empty response.`);
-    try {
-      return JSON.parse(decoder2.decode(await responseBytes(reader, maxBytes * 1.5 + 65536)));
-    } catch (cause) {
-      throw Object.assign(
-        operationError(
-          "The sharing response could not be verified. Retry the pending operation.",
-          "E_WORKSPACE_RESPONSE_INVALID"
-        ),
-        { cause }
-      );
-    }
-  }
-  async function commitWorkspace2(custody, options = {}) {
-    if (!custody.pendingCreate) return getWorkspace2(custody, options);
-    const result = await request(custody, "", {
-      ...options,
-      method: "PUT",
-      body: custody.pendingCreate
-    });
-    assertContract(result, schemas.workspace);
-    if (result.id !== custody.id || result.version !== 1 || result.epoch !== 1 || result.currentRevision !== custody.pendingCreate.revision.id || canonicalizeJson(result.ownerPublicKey) !== canonicalizeJson(custody.ownerPublicKey) || canonicalizeJson(result.keyring) !== canonicalizeJson(custody.keyring))
-      throw new Error("The sharing creation receipt is invalid. Retry the saved operation.");
-    custody.version = result.version;
-    custody.currentRevision = result.currentRevision;
-    delete custody.pendingCreate;
-    return result;
-  }
-  async function getWorkspace2(access, options = {}) {
-    const result = assertContract(await request(access, "", options), schemas.workspace);
-    if (result.id !== access.id) throw new Error("Shared review identity mismatch.");
-    const ring = await unseal(
-      result.keyring,
-      await tokenMaterial(access.token, access.id, "key-wrap"),
-      keyringContext(access.id, result.epoch)
-    );
-    if (canonicalizeJson(ring.ownerPublicKey) !== canonicalizeJson(result.ownerPublicKey) || access.ownerPublicKey && canonicalizeJson(access.ownerPublicKey) !== canonicalizeJson(result.ownerPublicKey))
-      throw new Error("Shared review owner identity changed.");
-    if (!ring.keys?.[result.epoch] || Object.entries(ring.keys).some(
-      ([keyEpoch, key]) => !/^[1-9][0-9]*$/u.test(keyEpoch) || !tokenPattern.test(key)
-    ))
-      throw new Error("Invalid shared review key history.");
-    Object.assign(access, {
-      keys: ring.keys,
-      ownerPublicKey: result.ownerPublicKey,
-      epoch: result.epoch,
-      keyring: result.keyring,
-      version: result.version,
-      currentRevision: result.currentRevision,
-      commentsPaused: result.commentsPaused
-    });
-    return result;
-  }
-  async function listWorkspaceRevisions(access, { after = "", ...options } = {}) {
-    if (after && !idPattern.test(after)) throw new TypeError("Invalid revision cursor.");
-    return request(
-      access,
-      `/revisions${after ? `?after=${encodeURIComponent(after)}` : ""}`,
-      options
-    );
-  }
-  async function decryptWorkspaceRevision2(access, revisionId = access.currentRevision, options = {}) {
-    if (!access.keys) await getWorkspace2(access, options);
-    if (!idPattern.test(revisionId))
-      throw new TypeError(`Invalid ${label.toLowerCase()} revision.`);
-    const revision = assertContract(
-      await request(access, `/revisions/${revisionId}`, options),
-      schemas.revision
-    );
-    if (revision.id !== revisionId || !await verifyWorkspaceSignature2(revision, access.ownerPublicKey))
-      throw new Error(`The published ${label.toLowerCase()} signature is invalid.`);
-    if (!access.keys[revision.epoch])
-      throw new Error("The access token cannot open this revision.");
-    const bundle = assertBundle(
-      await unpackBundle(
-        await unseal(
-          revision,
-          decodeWorkspaceBytes2(access.keys[revision.epoch]),
-          revisionContext(access.id, revision)
-        )
-      )
-    );
-    if (workspaceEnvelopeDigest2(digestInput(bundle)) !== revision.reviewOf)
-      throw new Error(`Published ${label.toLowerCase()} content does not match its revision.`);
-    return { ...bundle, workspaceRevision: revision.id, reviewOf: revision.reviewOf };
-  }
-  async function prepareWorkspaceMutation2(custody, action, payload = void 0) {
-    if (custody.pendingCreate)
-      throw new Error("Finish creating this shared review before changing it.");
-    if (custody.pendingMutation)
-      throw new Error("A sharing operation is pending. Retry it before making another change.");
-    const body = {
-      operationId: newWorkspaceId2(),
-      expectedVersion: custody.version,
-      epoch: custody.epoch
-    };
-    let next = {};
-    if (action === "publish") body.revision = await prepareRevision(custody, payload);
-    else if (action === "rotate") {
-      const token = newWorkspaceToken2();
-      const epoch = custody.epoch + 1;
-      const keys = { ...custody.keys, [epoch]: newWorkspaceToken2() };
-      const keyring = await wrapKeyring(custody, token, epoch, keys);
-      Object.assign(body, {
-        epoch,
-        reviewerAuthHash: sha256Hex(await deriveWorkspaceAuthentication2(token, custody.id)),
-        keyring
-      });
-      next = { token, epoch, keys, keyring };
-    } else if (["pause", "resume", "revoke", "delete"].includes(action)) body.action = action;
-    else throw new TypeError(`Unknown ${label.toLowerCase()} sharing operation.`);
-    custody.pendingMutation = {
-      action,
-      body: await signWorkspaceValue2(body, custody.ownerPrivateKey),
-      next
-    };
-    return custody.pendingMutation;
-  }
-  function assertDeletionReceipt(custody, result) {
-    if (result.schemaVersion !== version || result.id !== custody.id || result.deleted !== true || Object.keys(result).some((key) => !["schemaVersion", "id", "deleted"].includes(key)))
-      throw new Error("The deletion receipt is invalid. Retry the saved operation.");
-  }
-  function assertMutationReceipt(custody, pending, result) {
-    if (pending.action === "delete") return assertDeletionReceipt(custody, result);
-    assertContract(result, schemas.workspace);
-    const expectedRevision = pending.action === "publish" ? pending.body.revision.id : custody.currentRevision;
-    if (result.id !== custody.id || result.version !== pending.body.expectedVersion + 1 || result.epoch !== pending.body.epoch || result.currentRevision !== expectedRevision || canonicalizeJson(result.ownerPublicKey) !== canonicalizeJson(custody.ownerPublicKey) || canonicalizeJson(result.keyring) !== canonicalizeJson(pending.next.keyring ?? custody.keyring) || ["pause", "resume"].includes(pending.action) && result.commentsPaused !== (pending.action === "pause"))
-      throw new Error("The sharing operation receipt is invalid. Retry the saved operation.");
-  }
-  async function commitWorkspaceMutation2(custody, options = {}) {
-    const pending = custody.pendingMutation;
-    if (!pending) throw new Error("No sharing operation is pending.");
-    const suffix = ["publish", "rotate"].includes(pending.action) ? pending.action : "manage";
-    const result = await request(custody, `/${suffix}`, {
-      ...options,
-      method: "POST",
-      body: pending.body
-    });
-    assertMutationReceipt(custody, pending, result);
-    Object.assign(custody, pending.next, { version: pending.body.expectedVersion + 1 });
-    if (pending.action === "publish") custody.currentRevision = pending.body.revision.id;
-    if (pending.action === "pause" || pending.action === "resume")
-      custody.commentsPaused = pending.action === "pause";
-    if (pending.action === "revoke" || pending.action === "delete")
-      custody.status = pending.action === "revoke" ? "revoked" : "deleted";
-    delete custody.pendingMutation;
-    return result;
-  }
-  async function publishWorkspace(custody, bundle, options = {}) {
-    await prepareWorkspaceMutation2(custody, "publish", bundle);
-    return commitWorkspaceMutation2(custody, options);
-  }
-  async function rotateWorkspace(custody, options = {}) {
-    await prepareWorkspaceMutation2(custody, "rotate");
-    return commitWorkspaceMutation2(custody, options);
-  }
-  async function manageWorkspace(custody, action, options = {}) {
-    await prepareWorkspaceMutation2(custody, action);
-    return commitWorkspaceMutation2(custody, options);
-  }
-  async function prepareWorkspaceEvent2(access, payload, { revisionId = access.currentRevision, reviewOf = payload.reviewOf, signer } = {}) {
-    if (!access.keys) throw new Error("Unlock the shared review before commenting.");
-    assertFeedback(payload);
-    const identity = signer ?? await createWorkspaceSigner2();
-    const publicKey = canonicalWorkspacePublicKey2(identity.publicKey);
-    const header = { id: newWorkspaceId2(), revisionId, reviewOf, epoch: access.epoch };
-    const event = await signWorkspaceValue2(
-      {
-        ...header,
-        ...await seal(
-          payload,
-          decodeWorkspaceBytes2(access.keys[access.epoch]),
-          eventContext(access.id, header),
-          maxEventBytes
-        ),
-        publicKey
-      },
-      identity.privateKey
-    );
-    return assertContract(event, schemas.event);
-  }
-  async function appendWorkspaceEvent2(access, payload, { preparedEvent, signer, revisionId, reviewOf, ...options } = {}) {
-    const event = preparedEvent ?? await prepareWorkspaceEvent2(access, payload, {
-      signer,
-      revisionId,
-      reviewOf: reviewOf ?? payload.reviewOf
-    });
-    const result = await request(access, "/events", { ...options, method: "POST", body: event });
-    if (!result || typeof result !== "object" || Array.isArray(result) || !Number.isSafeInteger(result.sequence) || result.sequence < 1 || !result.event || typeof result.event !== "object" || Array.isArray(result.event))
-      throw new Error("The feedback receipt is invalid. Retry the saved operation.");
-    const { sequence: eventSequence, ...received } = result.event;
-    if (eventSequence !== void 0 && eventSequence !== result.sequence || canonicalizeJson(received) !== canonicalizeJson(event))
-      throw new Error(
-        "The feedback receipt does not match the saved event. Retry the saved operation."
-      );
-    return { event: { ...received, sequence: result.sequence }, sequence: result.sequence };
-  }
-  function assertEventPage(page, after) {
-    if (!Array.isArray(page.events) || page.events.length > 100 || !Number.isSafeInteger(page.cursor) || page.cursor < after || typeof page.hasMore !== "boolean")
-      throw new Error("Invalid shared feedback page.");
-  }
-  async function decryptEvent(access, record, sequence) {
-    assertContract(record, schemas.event);
-    if (!await verifyWorkspaceSignature2(record, record.publicKey))
-      throw new Error("Signature verification failed.");
-    if (!access.keys[record.epoch]) throw new Error("The encryption epoch is unavailable.");
-    const payload = await unseal(
-      record,
-      decodeWorkspaceBytes2(access.keys[record.epoch]),
-      eventContext(access.id, record),
-      maxEventBytes
-    );
-    assertFeedback(payload);
-    if (payload.reviewOf !== record.reviewOf) throw new Error("Feedback revision is invalid.");
-    return { ...record, sequence, payload };
-  }
-  function eventFromPage(item, pageIds, previousSequence, cursor) {
-    const { sequence, ...record } = item?.event ? { ...item.event, sequence: item.sequence } : item ?? {};
-    if (!Number.isSafeInteger(sequence) || sequence <= previousSequence || sequence > cursor)
-      throw new Error("Invalid shared feedback sequence.");
-    if (typeof record.id !== "string" || pageIds.has(record.id))
-      throw new Error("Invalid shared feedback event identity.");
-    pageIds.add(record.id);
-    return { sequence, record };
-  }
-  async function readWorkspaceEvents2(access, { after = 0, ...options } = {}) {
-    if (!Number.isSafeInteger(after) || after < 0) throw new TypeError("Invalid feedback cursor.");
-    if (!access.keys) await getWorkspace2(access, options);
-    const page = await request(access, `/events?after=${after}`, options);
-    assertEventPage(page, after);
-    const events = [], issues = [], pageIds = /* @__PURE__ */ new Set();
-    let previousSequence = after;
-    for (const item of page.events) {
-      const { sequence, record } = eventFromPage(item, pageIds, previousSequence, page.cursor);
-      previousSequence = sequence;
-      try {
-        events.push(await decryptEvent(access, record, sequence));
-      } catch {
-        issues.push({
-          sequence,
-          id: typeof record.id === "string" && idPattern.test(record.id) ? record.id : null,
-          reason: "Invalid encrypted feedback; not imported."
-        });
-      }
-    }
-    return { ...page, events, issues };
-  }
-  return {
-    encodeWorkspaceBytes: encodeWorkspaceBytes2,
-    decodeWorkspaceBytes: decodeWorkspaceBytes2,
-    newWorkspaceToken: newWorkspaceToken2,
-    newWorkspaceId: newWorkspaceId2,
-    normalizeWorkspaceBase: normalizeWorkspaceBase2,
-    workspaceReviewUrl: workspaceReviewUrl2,
-    deriveWorkspaceAuthentication: deriveWorkspaceAuthentication2,
-    canonicalWorkspacePublicKey: canonicalWorkspacePublicKey2,
-    createWorkspaceSigner: createWorkspaceSigner2,
-    signWorkspaceValue: signWorkspaceValue2,
-    verifyWorkspaceSignature: verifyWorkspaceSignature2,
-    workspaceEnvelopeDigest: workspaceEnvelopeDigest2,
-    prepareWorkspace: prepareWorkspace2,
-    commitWorkspace: commitWorkspace2,
-    getWorkspace: getWorkspace2,
-    listWorkspaceRevisions,
-    decryptWorkspaceRevision: decryptWorkspaceRevision2,
-    prepareWorkspaceMutation: prepareWorkspaceMutation2,
-    commitWorkspaceMutation: commitWorkspaceMutation2,
-    publishWorkspace,
-    rotateWorkspace,
-    manageWorkspace,
-    prepareWorkspaceEvent: prepareWorkspaceEvent2,
-    appendWorkspaceEvent: appendWorkspaceEvent2,
-    readWorkspaceEvents: readWorkspaceEvents2
-  };
-}
-
 // packages/design/lib/design/workspace-client.mjs
 var encoder = new TextEncoder();
 var decoder = new TextDecoder("utf-8", { fatal: true });
@@ -2425,7 +1799,7 @@ async function importDesignShareRecovery(file, { input, ...options } = {}) {
       const pending = custody.pendingCreate ?? custody.pendingMutation.body;
       const destination = join3(root, "uploads", custody.id, pending.operationId);
       if (existsSync4(destination)) {
-        const { spoolChunkReader: spoolChunkReader2 } = await import("./design-generated-b0798298053515fd.mjs");
+        const { spoolChunkReader: spoolChunkReader2 } = await import("./design-runtime-support-5cb7531bede8.mjs");
         const reader = spoolChunkReader2(destination, pending);
         for (const part of pending.manifest.chunks) await reader(part.index);
       } else await copyUploadSpool(custody, destination);
@@ -2601,7 +1975,6 @@ export {
   resolveArtifactReviewDestination,
   decodeArtifactReviewSources,
   getDesignShareStatus,
-  prepareDesignShareBundle,
   shareDesign,
   publishDesignShare,
   manageDesignShare,