openplanr 2.2640.8 → 2.2641.0

package/lib/host-packages/{openai/openplanr/runtime/design/scripts/design-pako-esm.mjs → cursor/openplanr/runtime/design/scripts/design-compression.mjs}

@@ -1,26 +1,3 @@
-import {
-  LARGE_OBJECT_CHUNK_CONTEXT,
-  LARGE_OBJECT_LIMITS,
-  RESOURCE_HTML_SEGMENT_ENCODING,
-  assertLargeObjectContract,
-  canonicalizeJson,
-  sha256Hex
-} from "./design-bounded-json-data.mjs";
-
-// packages/artifact/lib/artifact/upload-spool.mjs
-import {
-  closeSync as closeSync2,
-  constants as constants2,
-  existsSync as existsSync2,
-  fstatSync,
-  fsyncSync as fsyncSync2,
-  lstatSync as lstatSync2,
-  openSync as openSync2,
-  readSync,
-  writeFileSync as writeFileSync2
-} from "node:fs";
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
-
 // node_modules/pako/dist/pako.esm.mjs
 /*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
 var Z_FIXED$1 = 4;
@@ -4197,1503 +4174,7 @@ var { Inflate, inflate, inflateRaw, ungzip } = inflate_1$1;
 var deflateRaw_1 = deflateRaw;
 var Inflate_1 = Inflate;
 
-// packages/artifact/lib/artifact/resource-pack.mjs
-var encoder = new TextEncoder();
-var decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
-var htmlSegmentMagic = encoder.encode(`\0${RESOURCE_HTML_SEGMENT_ENCODING}\0`);
-var blockPattern = /(<(script|style)\b[^>]*>)([\s\S]*?)<\/\2\s*>/gi;
-function encodeResourceBytes(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 decodeResourceBytes(value, maxBytes = 65536) {
-  if (typeof value !== "string" || !/^[A-Za-z0-9_-]+$/u.test(value) || value.length > Math.ceil(maxBytes * 4 / 3))
-    throw new TypeError("Invalid encoded resource value.");
-  const bytes = Uint8Array.from(
-    atob(value.replaceAll("-", "+").replaceAll("_", "/")),
-    (char) => char.charCodeAt(0)
-  );
-  if (bytes.byteLength > maxBytes || encodeResourceBytes(bytes) !== value)
-    throw new TypeError("Noncanonical resource encoding.");
-  return bytes;
-}
-async function resourceSha256(bytes) {
-  return [...new Uint8Array(await crypto.subtle.digest("SHA-256", bytes))].map((part) => part.toString(16).padStart(2, "0")).join("");
-}
-function encodeResource(bytes) {
-  const compressed = deflateRaw_1(bytes);
-  return compressed.byteLength < bytes.byteLength ? { bytes: compressed, codec: "deflate-raw" } : { bytes, codec: "identity" };
-}
-function decodeResource(bytes, descriptor, maxBytes = LARGE_OBJECT_LIMITS.decodedBytes) {
-  if (descriptor.encodedBytes !== bytes.byteLength || descriptor.decodedBytes > maxBytes || descriptor.decodedBytes < 1)
-    throw new RangeError("Resource size is invalid.");
-  if (descriptor.codec === "identity") {
-    if (bytes.byteLength !== descriptor.decodedBytes)
-      throw new TypeError("Identity resource length differs.");
-    return bytes;
-  }
-  if (descriptor.codec !== "deflate-raw") throw new TypeError("Unsupported resource codec.");
-  const inflater = new Inflate_1({ raw: true, chunkSize: 65536 });
-  const chunks = [];
-  let size = 0;
-  inflater.onData = (part) => {
-    size += part.byteLength;
-    if (size > descriptor.decodedBytes || size > maxBytes)
-      throw new RangeError("Resource expands beyond its declared limit.");
-    chunks.push(part);
-  };
-  inflater.push(bytes, true);
-  if (!inflater.ended && !inflater.err && inflater.strm?.avail_in === 0)
-    inflater.push(new Uint8Array(0), true);
-  if (!inflater.ended || inflater.err || size !== descriptor.decodedBytes || inflater.strm?.avail_in)
-    throw new TypeError("Compressed resource is corrupt or has trailing data.");
-  const output = new Uint8Array(size);
-  let offset = 0;
-  for (const part of chunks) {
-    output.set(part, offset);
-    offset += part.byteLength;
-  }
-  return output;
-}
-function jsonStringByteLength(value, maxBytes) {
-  let bytes = 2;
-  for (let index = 0; index < value.length; index++) {
-    const code = value.charCodeAt(index);
-    if (code === 34 || code === 92) bytes += 2;
-    else if (code < 32) bytes += [8, 9, 10, 12, 13].includes(code) ? 2 : 6;
-    else if (code < 128) bytes++;
-    else if (code < 2048) bytes += 2;
-    else if (code >= 55296 && code <= 56319) {
-      const next = value.charCodeAt(index + 1);
-      if (next >= 56320 && next <= 57343) {
-        bytes += 4;
-        index++;
-      } else bytes += 6;
-    } else bytes += code >= 56320 && code <= 57343 ? 6 : 3;
-    if (bytes > maxBytes) throw new RangeError("Resource pack exceeds its decoded byte limit.");
-  }
-  return bytes;
-}
-function utf8SegmentInfo(text, maximum) {
-  let bytes = 0, wellFormed = true;
-  for (let index = 0; index < text.length; index++) {
-    const code = text.charCodeAt(index);
-    if (code < 128) bytes++;
-    else if (code < 2048) bytes += 2;
-    else if (code >= 55296 && code <= 56319) {
-      const next = text.charCodeAt(index + 1);
-      if (next >= 56320 && next <= 57343) {
-        bytes += 4;
-        index++;
-      } else {
-        bytes += 3;
-        wellFormed = false;
-      }
-    } else {
-      bytes += 3;
-      if (code >= 56320 && code <= 57343) wellFormed = false;
-    }
-    if (bytes > maximum) throw new RangeError("Resource pack exceeds its decoded byte limit.");
-  }
-  return { bytes, wellFormed };
-}
-function segmentText(segment) {
-  if (typeof segment === "string") return { type: 0, text: segment };
-  if (!segment || typeof segment !== "object" || Array.isArray(segment))
-    throw new TypeError("Source segment is invalid.");
-  const descriptors = Object.getOwnPropertyDescriptors(segment);
-  if (Reflect.ownKeys(descriptors).length !== 1 || !Object.hasOwn(descriptors, "resourceId") || !Object.hasOwn(descriptors.resourceId, "value") || typeof descriptors.resourceId.value !== "string" || !/^r[0-9]{1,4}$/u.test(descriptors.resourceId.value))
-    throw new TypeError("Source segment is invalid.");
-  return { type: 1, text: descriptors.resourceId.value };
-}
-function encodeHtmlSegments(segments, maxBytes = LARGE_OBJECT_LIMITS.decodedBytes) {
-  if (!Array.isArray(segments) || !segments.length || segments.length > LARGE_OBJECT_LIMITS.resources * 2 + 1 || !Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > LARGE_OBJECT_LIMITS.decodedBytes)
-    throw new RangeError("Source segment count or byte limit is invalid.");
-  let byteLength = htmlSegmentMagic.byteLength + 4, wellFormed = true;
-  const parts = [];
-  for (const segment of segments) {
-    const part = segmentText(segment);
-    byteLength += 5;
-    if (byteLength > maxBytes)
-      throw new RangeError("Resource pack exceeds its decoded byte limit.");
-    const info = utf8SegmentInfo(part.text, maxBytes - byteLength);
-    byteLength += info.bytes;
-    wellFormed &&= info.wellFormed;
-    parts.push({ ...part, byteLength: info.bytes });
-  }
-  if (!wellFormed) throw new TypeError("Source segment text is not valid Unicode.");
-  const bytes = new Uint8Array(byteLength), view = new DataView(bytes.buffer);
-  bytes.set(htmlSegmentMagic);
-  view.setUint32(htmlSegmentMagic.byteLength, parts.length);
-  let cursor = htmlSegmentMagic.byteLength + 4;
-  for (const part of parts) {
-    bytes[cursor++] = part.type;
-    view.setUint32(cursor, part.byteLength);
-    cursor += 4;
-    const encoded = encoder.encodeInto(part.text, bytes.subarray(cursor, cursor + part.byteLength));
-    if (encoded.read !== part.text.length || encoded.written !== part.byteLength)
-      throw new TypeError("Source segment byte accounting differs.");
-    cursor += part.byteLength;
-  }
-  return bytes;
-}
-function decodeHtmlSegments(bytes, maxBytes = LARGE_OBJECT_LIMITS.decodedBytes) {
-  if (!(bytes instanceof Uint8Array) || !bytes.byteLength || bytes.byteLength > maxBytes || !Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > LARGE_OBJECT_LIMITS.decodedBytes)
-    throw new RangeError("Source segment bytes exceed their limit.");
-  if (bytes[0] !== 0) {
-    const segments2 = JSON.parse(decoder.decode(bytes));
-    if (!Array.isArray(segments2) || !segments2.length || segments2.length > LARGE_OBJECT_LIMITS.resources * 2 + 1)
-      throw new TypeError("Source segment count is invalid.");
-    for (const segment of segments2) segmentText(segment);
-    return segments2;
-  }
-  if (bytes.byteLength < htmlSegmentMagic.byteLength + 4 || htmlSegmentMagic.some((byte, index) => byte !== bytes[index]))
-    throw new TypeError("Source segment encoding is unsupported or corrupt.");
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  const count = view.getUint32(htmlSegmentMagic.byteLength);
-  if (!count || count > LARGE_OBJECT_LIMITS.resources * 2 + 1)
-    throw new TypeError("Source segment count is invalid.");
-  const segments = [];
-  let cursor = htmlSegmentMagic.byteLength + 4;
-  for (let index = 0; index < count; index++) {
-    if (bytes.byteLength - cursor < 5) throw new TypeError("Source segment span is truncated.");
-    const type = bytes[cursor++], length = view.getUint32(cursor);
-    cursor += 4;
-    if (![0, 1].includes(type) || length > bytes.byteLength - cursor || type === 1 && length > 128)
-      throw new TypeError("Source segment span is invalid.");
-    const text = decoder.decode(bytes.subarray(cursor, cursor + length));
-    cursor += length;
-    const segment = type === 0 ? text : { resourceId: text };
-    segmentText(segment);
-    segments.push(segment);
-  }
-  if (cursor !== bytes.byteLength) throw new TypeError("Source segment bytes have trailing data.");
-  return segments;
-}
-async function packResourceBundle(bundle, { reviewOf } = {}) {
-  if (reviewOf !== void 0 && !/^[a-f0-9]{64}$/u.test(reviewOf))
-    throw new TypeError("Invalid full review identity.");
-  const diagram = bundle?.kind === "openplanr-diagram-review-bundle";
-  const envelope = diagram ? { schemaVersion: "1.0.0", artifacts: [{ id: "diagram", html: bundle.scene?.svg }] } : bundle?.envelope;
-  const views = envelope?.artifacts;
-  if (!Array.isArray(views) || !views.length || views.length > LARGE_OBJECT_LIMITS.views || new Set(views.map((view) => view.id)).size !== views.length)
-    throw new RangeError("Resource pack view count or identity is invalid.");
-  const pooled = envelope.schemaVersion === "1.1.0";
-  let sources;
-  const viewSources = /* @__PURE__ */ Object.create(null);
-  if (pooled) {
-    sources = envelope.sources;
-    if (!Array.isArray(sources) || !sources.length || sources.length > LARGE_OBJECT_LIMITS.sources || new Set(sources.map((source) => source.id)).size !== sources.length)
-      throw new RangeError("Resource pack source count or identity is invalid.");
-    const sourceIds = new Set(sources.map((source) => source.id));
-    for (const view of views) {
-      if (!sourceIds.has(view.sourceId)) throw new TypeError("View references an unknown source.");
-      viewSources[view.id] = view.sourceId;
-    }
-  } else {
-    sources = [];
-    const pages = /* @__PURE__ */ new Map();
-    for (const view of views) {
-      if (typeof view.html !== "string") throw new TypeError("View has no HTML source.");
-      if (!pages.has(view.html)) {
-        const id = `source-${sources.length}`;
-        pages.set(view.html, id);
-        sources.push({ id, html: view.html });
-      }
-      viewSources[view.id] = pages.get(view.html);
-    }
-  }
-  if (sources.length > LARGE_OBJECT_LIMITS.sources)
-    throw new RangeError("Resource pack exceeds its source limit.");
-  const blocks = /* @__PURE__ */ new Map();
-  const resources = [];
-  const encodedResources = [];
-  let encodedBytes = 0, decodedBytes = 0, uniqueHtmlBytes = 0;
-  async function addResource(type, bytes) {
-    if (!bytes.byteLength || resources.length >= LARGE_OBJECT_LIMITS.resources)
-      throw new RangeError("Resource count exceeds its limit.");
-    if (bytes.byteLength > LARGE_OBJECT_LIMITS.decodedBytes - decodedBytes)
-      throw new RangeError("Resource pack exceeds its decoded byte limit.");
-    const encoded = encodeResource(bytes);
-    const descriptor = {
-      id: `r${resources.length}`,
-      type,
-      offset: encodedBytes,
-      encodedBytes: encoded.bytes.byteLength,
-      decodedBytes: bytes.byteLength,
-      codec: encoded.codec,
-      sha256: await resourceSha256(bytes)
-    };
-    encodedBytes += descriptor.encodedBytes;
-    decodedBytes += descriptor.decodedBytes;
-    if (decodedBytes > LARGE_OBJECT_LIMITS.decodedBytes || encodedBytes > LARGE_OBJECT_LIMITS.decodedBytes)
-      throw new RangeError("Resource pack exceeds its decoded byte limit.");
-    resources.push(descriptor);
-    encodedResources.push(encoded.bytes);
-    return descriptor.id;
-  }
-  const sourceRecords = [];
-  for (const source of sources) {
-    if (typeof source.html !== "string" || !source.html.length)
-      throw new TypeError("Source HTML is invalid.");
-    let info;
-    try {
-      info = utf8SegmentInfo(source.html, LARGE_OBJECT_LIMITS.uniqueHtmlBytes - uniqueHtmlBytes);
-    } catch {
-      throw new RangeError("Resource pack exceeds its unique HTML limit.");
-    }
-    if (!info.wellFormed) throw new TypeError("Source HTML is not valid Unicode.");
-    uniqueHtmlBytes += info.bytes;
-    const htmlBytes = encoder.encode(source.html);
-    const sha256 = await resourceSha256(htmlBytes);
-    if (source.sha256 && source.sha256 !== sha256)
-      throw new TypeError("Source digest does not match its HTML.");
-    const segments = [];
-    let offset = 0;
-    for (const match of source.html.matchAll(blockPattern)) {
-      const body = match[3];
-      if (segments.length >= LARGE_OBJECT_LIMITS.resources * 2 || body.length < 2048 || !blocks.has(body) && blocks.size >= 512)
-        continue;
-      const start = match.index + match[1].length;
-      segments.push(source.html.slice(offset, start));
-      if (!blocks.has(body))
-        blocks.set(body, await addResource("shared-block", encoder.encode(body)));
-      segments.push({ resourceId: blocks.get(body) });
-      offset = start + body.length;
-    }
-    segments.push(source.html.slice(offset));
-    const resourceId = await addResource(
-      "html-segments",
-      encodeHtmlSegments(segments, LARGE_OBJECT_LIMITS.decodedBytes - decodedBytes)
-    );
-    sourceRecords.push({ id: source.id, resourceId, htmlBytes: htmlBytes.byteLength, sha256 });
-  }
-  const withoutHtml = ({ html: _html, ...value }) => value;
-  const metadata = diagram ? { ...bundle, scene: { ...bundle.scene, svg: "" } } : {
-    ...bundle,
-    envelope: {
-      ...envelope,
-      artifacts: views.map(withoutHtml),
-      ...pooled ? { sources: sources.map(withoutHtml) } : {}
-    }
-  };
-  const catalog = {
-    schemaVersion: "1.0.0",
-    kind: "openplanr-resource-catalog",
-    ...reviewOf === void 0 ? {} : { reviewOf },
-    bundle: metadata,
-    uniqueHtmlBytes,
-    totalDecodedBytes: decodedBytes,
-    resources,
-    sources: sourceRecords,
-    viewSources
-  };
-  let catalogBytes;
-  for (let attempt = 0; attempt < 4; attempt++) {
-    catalogBytes = encoder.encode(canonicalizeJson(catalog));
-    const total = decodedBytes + catalogBytes.byteLength;
-    if (catalog.totalDecodedBytes === total) break;
-    catalog.totalDecodedBytes = total;
-  }
-  catalogBytes = encoder.encode(canonicalizeJson(catalog));
-  if (decodedBytes + catalogBytes.byteLength !== catalog.totalDecodedBytes || catalog.totalDecodedBytes > LARGE_OBJECT_LIMITS.decodedBytes)
-    throw new RangeError("Resource pack total exceeds its decoded limit.");
-  assertLargeObjectContract(catalog, "resource-catalog");
-  const encodedCatalog = encodeResource(catalogBytes);
-  const catalogSpan = {
-    offset: encodedBytes,
-    encodedBytes: encodedCatalog.bytes.byteLength,
-    decodedBytes: catalogBytes.byteLength,
-    codec: encodedCatalog.codec
-  };
-  return {
-    catalog,
-    catalogSpan,
-    encodedResources: [...encodedResources, encodedCatalog.bytes],
-    plaintextBytes: encodedBytes + encodedCatalog.bytes.byteLength
-  };
-}
-function resourceChunkAAD(manifest, index) {
-  return encoder.encode(
-    canonicalizeJson({
-      context: LARGE_OBJECT_CHUNK_CONTEXT,
-      workspaceId: manifest.workspaceId,
-      revisionId: manifest.revisionId,
-      epoch: manifest.epoch,
-      index
-    })
-  );
-}
-async function encryptResourcePack(pack, { workspaceId, revisionId, epoch, rawKey, sign, createdAt = (/* @__PURE__ */ new Date()).toISOString() }) {
-  const header = {
-    schemaVersion: "2.0.0",
-    kind: "openplanr-encrypted-resource-manifest",
-    workspaceId,
-    revisionId,
-    epoch,
-    createdAt,
-    plaintextBytes: pack.plaintextBytes,
-    catalog: pack.catalogSpan
-  };
-  const key = await crypto.subtle.importKey("raw", rawKey, "AES-GCM", false, ["encrypt"]);
-  const chunks = [];
-  const descriptors = [];
-  const ivs = /* @__PURE__ */ new Set();
-  let part = new Uint8Array(LARGE_OBJECT_LIMITS.chunkPlaintextBytes), filled = 0;
-  async function flush() {
-    if (!filled) return;
-    let iv, encodedIv;
-    do {
-      iv = crypto.getRandomValues(new Uint8Array(12));
-      encodedIv = encodeResourceBytes(iv);
-    } while (ivs.has(encodedIv));
-    ivs.add(encodedIv);
-    const index = chunks.length;
-    const cipher = new Uint8Array(
-      await crypto.subtle.encrypt(
-        { name: "AES-GCM", iv, additionalData: resourceChunkAAD(header, index), tagLength: 128 },
-        key,
-        part.subarray(0, filled)
-      )
-    );
-    if (chunks.length >= LARGE_OBJECT_LIMITS.chunks)
-      throw new RangeError("Encrypted pack exceeds its chunk limit.");
-    chunks.push(cipher);
-    descriptors.push({
-      index,
-      iv: encodedIv,
-      byteLength: cipher.byteLength,
-      sha256: await resourceSha256(cipher)
-    });
-    filled = 0;
-  }
-  for (const bytes of pack.encodedResources) {
-    for (let offset = 0; offset < bytes.byteLength; ) {
-      const take = Math.min(part.byteLength - filled, bytes.byteLength - offset);
-      part.set(bytes.subarray(offset, offset + take), filled);
-      filled += take;
-      offset += take;
-      if (filled === part.byteLength) await flush();
-    }
-  }
-  await flush();
-  part.fill(0);
-  const manifest = await sign({
-    ...header,
-    ciphertextBytes: chunks.reduce((sum, value) => sum + value.byteLength, 0),
-    chunks: descriptors
-  });
-  assertLargeObjectContract(manifest, "encrypted-resource-manifest");
-  return { manifest, chunks };
-}
-async function openResourcePack(manifest, { rawKey, verify, fetchChunk, maxCachedBytes = 8 * 1024 * 1024 }) {
-  assertLargeObjectContract(manifest, "encrypted-resource-manifest");
-  if (!await verify(manifest)) throw new TypeError("Resource manifest signature is invalid.");
-  const key = await crypto.subtle.importKey("raw", rawKey, "AES-GCM", false, ["decrypt"]);
-  const cache = /* @__PURE__ */ new Map();
-  let cacheBytes = 0, disposed = false;
-  if (!Number.isSafeInteger(maxCachedBytes) || maxCachedBytes < LARGE_OBJECT_LIMITS.chunkBytes || maxCachedBytes > LARGE_OBJECT_LIMITS.decodedBytes)
-    throw new RangeError("Resource cache bound is invalid.");
-  async function chunkAt(index) {
-    if (disposed) throw new Error("Resource pack has been disposed.");
-    if (cache.has(index)) {
-      const bytes2 = cache.get(index);
-      cache.delete(index);
-      cache.set(index, bytes2);
-      return bytes2;
-    }
-    const descriptor = manifest.chunks[index];
-    const bytes = await fetchChunk(index, descriptor);
-    if (!(bytes instanceof Uint8Array) || bytes.byteLength !== descriptor.byteLength || await resourceSha256(bytes) !== descriptor.sha256)
-      throw new TypeError("Ciphertext chunk integrity check failed.");
-    const plaintext = new Uint8Array(
-      await crypto.subtle.decrypt(
-        {
-          name: "AES-GCM",
-          iv: decodeResourceBytes(descriptor.iv, 12),
-          additionalData: resourceChunkAAD(manifest, index),
-          tagLength: 128
-        },
-        key,
-        bytes
-      )
-    );
-    if (disposed) {
-      plaintext.fill(0);
-      throw new Error("Resource pack has been disposed.");
-    }
-    cache.set(index, plaintext);
-    cacheBytes += plaintext.byteLength;
-    while (cacheBytes > maxCachedBytes && cache.size > 1) {
-      const first = cache.keys().next().value;
-      cacheBytes -= cache.get(first).byteLength;
-      cache.delete(first);
-    }
-    return plaintext;
-  }
-  return openPackedResources({
-    catalogSpan: manifest.catalog,
-    plaintextBytes: manifest.plaintextBytes,
-    chunkPlaintextBytes: LARGE_OBJECT_LIMITS.chunkPlaintextBytes,
-    chunkAt,
-    dispose() {
-      disposed = true;
-      for (const bytes of cache.values()) bytes.fill(0);
-      cache.clear();
-      cacheBytes = 0;
-    }
-  });
-}
-async function openPackedResources({
-  catalogSpan,
-  plaintextBytes,
-  chunkPlaintextBytes,
-  chunkAt,
-  dispose = () => {
-  }
-}) {
-  async function spanBytes(span) {
-    if (!Number.isSafeInteger(span.offset) || !Number.isSafeInteger(span.encodedBytes) || span.offset < 0 || span.encodedBytes < 1 || span.offset + span.encodedBytes > plaintextBytes)
-      throw new TypeError("Resource span is invalid.");
-    const bytes = new Uint8Array(span.encodedBytes);
-    for (let copied = 0; copied < bytes.byteLength; ) {
-      const absolute = span.offset + copied, index = Math.floor(absolute / chunkPlaintextBytes), within = absolute % chunkPlaintextBytes;
-      const chunk = await chunkAt(index);
-      const take = Math.min(chunk.byteLength - within, bytes.byteLength - copied);
-      if (take < 1) throw new TypeError("Resource span exceeds its chunks.");
-      bytes.set(chunk.subarray(within, within + take), copied);
-      copied += take;
-    }
-    return bytes;
-  }
-  const catalogBytes = decodeResource(
-    await spanBytes(catalogSpan),
-    catalogSpan,
-    LARGE_OBJECT_LIMITS.catalogBytes
-  );
-  const catalog = assertLargeObjectContract(
-    JSON.parse(decoder.decode(catalogBytes)),
-    "resource-catalog"
-  );
-  const resourceBytes = catalog.resources.reduce((sum, part) => sum + part.decodedBytes, 0);
-  const encodedBytes = catalog.resources.reduce((sum, part) => sum + part.encodedBytes, 0);
-  if (resourceBytes + catalogBytes.byteLength !== catalog.totalDecodedBytes || encodedBytes !== catalogSpan.offset)
-    throw new TypeError("Catalog and manifest byte accounting differ.");
-  const resources = new Map(catalog.resources.map((resource) => [resource.id, resource]));
-  const sourceRecords = new Map(catalog.sources.map((source) => [source.id, source]));
-  async function resourceAt(id, expectedType, maxBytes = LARGE_OBJECT_LIMITS.decodedBytes) {
-    const descriptor = resources.get(id);
-    if (!descriptor || descriptor.type !== expectedType || descriptor.offset + descriptor.encodedBytes > catalogSpan.offset)
-      throw new TypeError("Resource reference is invalid.");
-    if (descriptor.decodedBytes > maxBytes || descriptor.encodedBytes > maxBytes)
-      throw new RangeError("Selected source resource exceeds its read limit.");
-    const decoded = decodeResource(await spanBytes(descriptor), descriptor, maxBytes);
-    if (await resourceSha256(decoded) !== descriptor.sha256)
-      throw new TypeError("Decoded resource integrity check failed.");
-    return decoded;
-  }
-  async function loadSource(id, { maxSourceBytes } = {}) {
-    const source = sourceRecords.get(id);
-    if (!source) throw new TypeError("Unknown source.");
-    if (maxSourceBytes !== void 0 && (!Number.isSafeInteger(maxSourceBytes) || maxSourceBytes < 1 || maxSourceBytes > LARGE_OBJECT_LIMITS.uniqueHtmlBytes))
-      throw new RangeError("Selected source read limit is invalid.");
-    if (maxSourceBytes !== void 0 && source.htmlBytes > maxSourceBytes)
-      throw new RangeError("Selected source exceeds its read limit.");
-    const segmentLimit = maxSourceBytes === void 0 ? LARGE_OBJECT_LIMITS.decodedBytes : Math.min(
-      LARGE_OBJECT_LIMITS.decodedBytes,
-      maxSourceBytes * 6 + (LARGE_OBJECT_LIMITS.resources * 2 + 1) * 160 + htmlSegmentMagic.byteLength + 4
-    );
-    const segments = decodeHtmlSegments(
-      await resourceAt(source.resourceId, "html-segments", segmentLimit),
-      segmentLimit
-    );
-    if (!Array.isArray(segments) || segments.length > LARGE_OBJECT_LIMITS.resources * 2 + 1)
-      throw new TypeError("Source segment count is invalid.");
-    const parts = [];
-    let htmlBytes = 0;
-    for (const segment of segments) {
-      let text;
-      if (typeof segment === "string") text = segment;
-      else if (segment && Object.keys(segment).length === 1 && typeof segment.resourceId === "string")
-        text = decoder.decode(
-          await resourceAt(
-            segment.resourceId,
-            "shared-block",
-            maxSourceBytes ?? LARGE_OBJECT_LIMITS.decodedBytes
-          )
-        );
-      else throw new TypeError("Source segment is invalid.");
-      htmlBytes += encoder.encode(text).byteLength;
-      if (htmlBytes > source.htmlBytes)
-        throw new RangeError("Source expands beyond its declared limit.");
-      parts.push(text);
-    }
-    const html = parts.join("");
-    if (htmlBytes !== source.htmlBytes || await resourceSha256(encoder.encode(html)) !== source.sha256)
-      throw new TypeError("Reconstructed HTML integrity check failed.");
-    return html;
-  }
-  async function loadView(viewId, options) {
-    if (catalog.bundle.kind === "openplanr-diagram-review-bundle") {
-      if (viewId !== "diagram") throw new TypeError("Unknown diagram view.");
-      return { id: "diagram", html: await loadSource(catalog.viewSources.diagram, options) };
-    }
-    const view = catalog.bundle.envelope.artifacts.find((item) => item.id === viewId);
-    if (!view || !Object.hasOwn(catalog.viewSources, viewId)) throw new TypeError("Unknown view.");
-    return { ...view, html: await loadSource(catalog.viewSources[viewId], options) };
-  }
-  async function loadBundle({ sourcePool = false } = {}) {
-    const metadataBytes = encoder.encode(canonicalizeJson(catalog.bundle)).byteLength;
-    const poolInline = sourcePool && catalog.bundle.kind === "openplanr-design-review-bundle" && catalog.bundle.envelope.schemaVersion !== "1.1.0";
-    const references = catalog.bundle.kind === "openplanr-diagram-review-bundle" ? [{ id: catalog.viewSources.diagram, field: null }] : catalog.bundle.envelope.schemaVersion === "1.1.0" ? catalog.bundle.envelope.sources.map((source) => ({ id: source.id, field: "html" })) : poolInline ? catalog.sources.map((source) => ({ id: source.id, field: "html" })) : catalog.bundle.envelope.artifacts.map((view) => ({
-      id: catalog.viewSources[view.id],
-      field: "html"
-    }));
-    const counts = /* @__PURE__ */ new Map();
-    let serializedBytes = metadataBytes;
-    for (const { id, field } of references) {
-      const source = sourceRecords.get(id);
-      if (!source) throw new TypeError("Unknown source.");
-      serializedBytes += source.htmlBytes + (field === null ? 0 : field.length + 6);
-      if (serializedBytes > LARGE_OBJECT_LIMITS.decodedBytes)
-        throw new RangeError(
-          "Complete bundle reconstruction exceeds its serialized byte limit. Use lazy views."
-        );
-      counts.set(id, (counts.get(id) ?? 0) + 1);
-    }
-    const uniqueRepresentation = [...counts.values()].every((count) => count === 1);
-    const htmlBySource = /* @__PURE__ */ new Map();
-    for (const [id, count] of counts) {
-      const html = await loadSource(id);
-      const source = sourceRecords.get(id);
-      if (!uniqueRepresentation) {
-        const escapedBytes = jsonStringByteLength(html, LARGE_OBJECT_LIMITS.decodedBytes);
-        serializedBytes += count * (escapedBytes - source.htmlBytes - 2);
-      }
-      if (serializedBytes > LARGE_OBJECT_LIMITS.decodedBytes)
-        throw new RangeError(
-          "Complete bundle reconstruction exceeds its serialized byte limit. Use lazy views."
-        );
-      htmlBySource.set(id, html);
-    }
-    const bundle = structuredClone(catalog.bundle);
-    if (poolInline) {
-      if (bundle.schemaVersion === "1.1.0") bundle.schemaVersion = "1.2.0";
-      bundle.envelope.schemaVersion = "1.1.0";
-      bundle.envelope.sources = catalog.sources.map((source) => ({
-        id: source.id,
-        kind: "html",
-        sha256: source.sha256,
-        html: htmlBySource.get(source.id)
-      }));
-      bundle.envelope.artifacts = bundle.envelope.artifacts.map((view) => ({
-        ...view,
-        sourceId: catalog.viewSources[view.id]
-      }));
-      const actualMetadata = {
-        ...bundle,
-        envelope: {
-          ...bundle.envelope,
-          sources: bundle.envelope.sources.map(({ html: _html, ...source }) => source)
-        }
-      };
-      const extraMetadata = encoder.encode(canonicalizeJson(actualMetadata)).byteLength - metadataBytes;
-      if (serializedBytes + extraMetadata > LARGE_OBJECT_LIMITS.decodedBytes)
-        throw new RangeError("Complete pooled reconstruction exceeds its serialized byte limit.");
-      return bundle;
-    }
-    if (bundle.kind === "openplanr-diagram-review-bundle")
-      bundle.scene.svg = htmlBySource.get(catalog.viewSources.diagram);
-    else if (bundle.envelope.schemaVersion === "1.1.0") {
-      for (const source of bundle.envelope.sources) source.html = htmlBySource.get(source.id);
-    } else
-      for (const view of bundle.envelope.artifacts)
-        view.html = htmlBySource.get(catalog.viewSources[view.id]);
-    return bundle;
-  }
-  return {
-    catalog: structuredClone(catalog),
-    bundle: structuredClone(catalog.bundle),
-    reviewOf: catalog.reviewOf,
-    loadSource,
-    loadView,
-    loadBundle,
-    assertMatchesBundle: (value) => assertResourceBundleMatchesCatalog(value, catalog),
-    dispose
-  };
-}
-async function assertResourceBundleMatchesCatalog(bundle, catalog) {
-  assertLargeObjectContract(catalog, "resource-catalog");
-  const diagram = bundle?.kind === "openplanr-diagram-review-bundle";
-  const envelope = diagram ? { schemaVersion: "1.0.0", artifacts: [{ id: "diagram", html: bundle.scene?.svg }] } : bundle?.envelope;
-  if (!Array.isArray(envelope?.artifacts))
-    throw new TypeError("Saved content differs from resource catalog.");
-  const sources = [], viewSources = /* @__PURE__ */ Object.create(null), pages = /* @__PURE__ */ new Map();
-  if (envelope.schemaVersion === "1.1.0") {
-    if (!Array.isArray(envelope.sources))
-      throw new TypeError("Saved content differs from resource catalog.");
-    sources.push(...envelope.sources);
-    for (const view of envelope.artifacts) viewSources[view.id] = view.sourceId;
-  } else
-    for (const view of envelope.artifacts) {
-      if (typeof view.html !== "string")
-        throw new TypeError("Saved content differs from resource catalog.");
-      if (!pages.has(view.html)) {
-        const id = `source-${sources.length}`;
-        pages.set(view.html, id);
-        sources.push({ id, html: view.html });
-      }
-      viewSources[view.id] = pages.get(view.html);
-    }
-  const withoutHtml = ({ html: _html, ...value }) => value;
-  const metadata = diagram ? { ...bundle, scene: { ...bundle.scene, svg: "" } } : {
-    ...bundle,
-    envelope: {
-      ...envelope,
-      artifacts: envelope.artifacts.map(withoutHtml),
-      ...envelope.schemaVersion === "1.1.0" ? { sources: sources.map(withoutHtml) } : {}
-    }
-  };
-  if (canonicalizeJson(metadata) !== canonicalizeJson(catalog.bundle) || canonicalizeJson(viewSources) !== canonicalizeJson(catalog.viewSources) || sources.length !== catalog.sources.length)
-    throw new TypeError("Saved content differs from resource catalog.");
-  const saved = new Map(catalog.sources.map((source) => [source.id, source]));
-  for (const source of sources) {
-    const record = saved.get(source.id);
-    if (!record || typeof source.html !== "string")
-      throw new TypeError("Saved source differs from resource catalog.");
-    const info = utf8SegmentInfo(source.html, record.htmlBytes);
-    if (!info.wellFormed || info.bytes !== record.htmlBytes)
-      throw new TypeError("Saved source differs from resource catalog.");
-    const bytes = encoder.encode(source.html);
-    if (await resourceSha256(bytes) !== record.sha256)
-      throw new TypeError("Saved source differs from resource catalog.");
-  }
-  return bundle;
-}
-
-// packages/artifact/lib/artifact/chunked-workspace-client.mjs
-var encoder2 = new TextEncoder();
-var decoder2 = new TextDecoder("utf-8", { fatal: true });
-var preparedChunks = /* @__PURE__ */ new WeakMap();
-async function boundedResponseBytes(response, limit) {
-  const declared = response.headers?.get("content-length");
-  if (declared !== void 0 && declared !== null && (!/^[0-9]+$/.test(declared) || BigInt(declared) > BigInt(limit))) {
-    await response.body?.cancel();
-    throw new RangeError("The sharing response declared size exceeds its byte limit.");
-  }
-  const reader = response.body?.getReader();
-  if (!reader) throw new TypeError("The sharing service returned an empty response.");
-  const chunks = [];
-  let size = 0;
-  try {
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      size += value.byteLength;
-      if (size > limit) {
-        await reader.cancel();
-        throw new RangeError("The sharing response exceeds its byte limit.");
-      }
-      chunks.push(value);
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const bytes = new Uint8Array(size);
-  let offset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return bytes;
-}
-function unsupported() {
-  return Object.assign(
-    new Error(
-      "This sharing service does not support bounded resource uploads. Upgrade the hosted service before sharing this design; your local work is saved."
-    ),
-    { code: "E_WORKSPACE_TRANSPORT_UNSUPPORTED", status: 426 }
-  );
-}
-function uploadChunksFor(custody) {
-  const body = custody.pendingCreate ?? (custody.pendingMutation?.action === "publish" ? custody.pendingMutation.body : null);
-  return body && preparedChunks.get(body);
-}
-function createChunkedWorkspaceClient({
-  legacy,
-  domain,
-  apiPath,
-  assertBundle,
-  assertFeedback,
-  digestInput = (value) => value,
-  digestBundle
-}) {
-  const api = apiPath.replace("/api/v1/", "/api/v2/");
-  const idPattern = /^[A-Za-z0-9_-]{22,64}$/u;
-  const tokenPattern = /^[A-Za-z0-9_-]{43}$/u;
-  function validateAccess(access) {
-    legacy.normalizeWorkspaceBase(access.baseUrl);
-    if (!idPattern.test(access.id)) throw new TypeError("Workspace identity is invalid.");
-  }
-  async function keyMaterial(token, id, purpose) {
-    if (!tokenPattern.test(token) || !idPattern.test(id))
-      throw new TypeError("Workspace token is invalid.");
-    const imported = await crypto.subtle.importKey(
-      "raw",
-      decodeResourceBytes(token, 32),
-      "HKDF",
-      false,
-      ["deriveBits"]
-    );
-    return new Uint8Array(
-      await crypto.subtle.deriveBits(
-        {
-          name: "HKDF",
-          hash: "SHA-256",
-          salt: encoder2.encode(id),
-          info: encoder2.encode(`${domain}/${purpose}`)
-        },
-        imported,
-        256
-      )
-    );
-  }
-  async function seal(value, rawKey, context, limit = 65536) {
-    const bytes = encoder2.encode(canonicalizeJson(value));
-    if (bytes.byteLength + 16 > limit)
-      throw new RangeError("Encrypted metadata exceeds its byte limit.");
-    const key = await crypto.subtle.importKey("raw", rawKey, "AES-GCM", false, ["encrypt"]);
-    const iv = crypto.getRandomValues(new Uint8Array(12));
-    const cipher = await crypto.subtle.encrypt(
-      {
-        name: "AES-GCM",
-        iv,
-        additionalData: encoder2.encode(canonicalizeJson(context)),
-        tagLength: 128
-      },
-      key,
-      bytes
-    );
-    return { iv: encodeResourceBytes(iv), ciphertext: encodeResourceBytes(new Uint8Array(cipher)) };
-  }
-  async function unseal(value, rawKey, context, limit = 65536) {
-    const key = await crypto.subtle.importKey("raw", rawKey, "AES-GCM", false, ["decrypt"]);
-    const bytes = await crypto.subtle.decrypt(
-      {
-        name: "AES-GCM",
-        iv: decodeResourceBytes(value.iv, 12),
-        additionalData: encoder2.encode(canonicalizeJson(context)),
-        tagLength: 128
-      },
-      key,
-      decodeResourceBytes(value.ciphertext, limit)
-    );
-    return JSON.parse(decoder2.decode(bytes));
-  }
-  async function wrap(custody, token = custody.token, epoch = custody.epoch, keys = custody.keys) {
-    return seal(
-      { keys, ownerPublicKey: custody.ownerPublicKey },
-      await keyMaterial(token, custody.id, "key-wrap"),
-      { type: "keyring", workspaceId: custody.id, epoch }
-    );
-  }
-  async function network(url, init, fetchImpl = globalThis.fetch) {
-    let response;
-    try {
-      response = await fetchImpl(url, {
-        redirect: "error",
-        credentials: "omit",
-        cache: "no-store",
-        signal: AbortSignal.timeout(2e4),
-        ...init
-      });
-    } catch (cause) {
-      throw Object.assign(
-        new Error(
-          "Sharing was interrupted. Retry the saved operation; its identity and bytes are retained."
-        ),
-        { code: "E_WORKSPACE_NETWORK", cause }
-      );
-    }
-    if (!response.ok) {
-      const error = Object.assign(
-        new Error(`Sharing failed (${response.status}). Retry the saved operation.`),
-        { status: response.status, code: `E_WORKSPACE_HTTP_${response.status}` }
-      );
-      try {
-        const value = JSON.parse(decoder2.decode(await boundedResponseBytes(response, 4096)));
-        if (/^[A-Za-z][A-Za-z0-9_-]{0,127}$/u.test(value.error ?? "")) error.code = value.error;
-      } catch {
-      }
-      const seconds = Number(response.headers.get("retry-after"));
-      if (response.status === 429 && Number.isFinite(seconds) && seconds > 0)
-        error.retryAfterSeconds = Math.min(3600, Math.ceil(seconds));
-      throw error;
-    }
-    return response;
-  }
-  async function capabilities({ baseUrl, fetchImpl } = {}) {
-    const response = await network(
-      `${legacy.normalizeWorkspaceBase(baseUrl)}/.well-known/openplanr-sharing`,
-      { method: "GET", headers: { Accept: "application/json" } },
-      fetchImpl
-    );
-    const value = JSON.parse(decoder2.decode(await boundedResponseBytes(response, 65536)));
-    if (!Array.isArray(value.workspaceTransports) || !value.workspaceTransports.includes("2"))
-      throw unsupported();
-    return value;
-  }
-  async function request(access, suffix = "", { method = "GET", body, binary, limit = 128 * 1024, fetchImpl, signal } = {}) {
-    validateAccess(access);
-    const auth = access.ownerAuth ?? await legacy.deriveWorkspaceAuthentication(access.token, access.id);
-    const headers = {
-      Authorization: `Bearer ${auth}`,
-      Accept: binary ? "application/octet-stream" : "application/json"
-    };
-    if (body !== void 0)
-      headers["Content-Type"] = binary ? "application/octet-stream" : "application/json";
-    const response = await network(
-      `${legacy.normalizeWorkspaceBase(access.baseUrl)}${api}/${access.id}${suffix}`,
-      {
-        method,
-        headers,
-        body: body === void 0 ? void 0 : binary ? body : canonicalizeJson(body),
-        ...signal ? { signal } : {}
-      },
-      fetchImpl
-    );
-    if (response.status === 204) return {};
-    const bytes = await boundedResponseBytes(response, limit);
-    return binary ? bytes : JSON.parse(decoder2.decode(bytes));
-  }
-  async function prepareUpload(custody, bundle) {
-    assertBundle(bundle);
-    const reviewOf = digestBundle ? digestBundle(bundle) : legacy.workspaceEnvelopeDigest(digestInput(bundle));
-    const encrypted = await encryptResourcePack(await packResourceBundle(bundle, { reviewOf }), {
-      workspaceId: custody.id,
-      revisionId: legacy.newWorkspaceId(),
-      epoch: custody.epoch,
-      rawKey: decodeResourceBytes(custody.keys[custody.epoch], 32),
-      sign: (value) => legacy.signWorkspaceValue(value, custody.ownerPrivateKey)
-    });
-    const body = await legacy.signWorkspaceValue(
-      {
-        schemaVersion: "2.0.0",
-        workspaceId: custody.id,
-        operationId: legacy.newWorkspaceId(),
-        expectedVersion: custody.version,
-        epoch: custody.epoch,
-        ownerPublicKey: custody.ownerPublicKey,
-        ownerAuthHash: sha256Hex(custody.ownerAuth),
-        reviewerAuthHash: sha256Hex(
-          await legacy.deriveWorkspaceAuthentication(custody.token, custody.id)
-        ),
-        keyring: custody.keyring,
-        manifest: encrypted.manifest
-      },
-      custody.ownerPrivateKey
-    );
-    assertLargeObjectContract(body, "encrypted-upload-prepare");
-    preparedChunks.set(body, encrypted.chunks);
-    return body;
-  }
-  async function prepareWorkspace(bundle, { baseUrl } = {}) {
-    const signer = await legacy.createWorkspaceSigner();
-    const custody = {
-      schemaVersion: "2.0.0",
-      id: legacy.newWorkspaceId(),
-      baseUrl: legacy.normalizeWorkspaceBase(baseUrl),
-      token: legacy.newWorkspaceToken(),
-      ownerAuth: legacy.newWorkspaceToken(),
-      ownerPrivateKey: signer.privateKey,
-      ownerPublicKey: signer.publicKey,
-      epoch: 1,
-      keys: { 1: legacy.newWorkspaceToken() },
-      version: 0
-    };
-    custody.keyring = await wrap(custody);
-    custody.pendingCreate = await prepareUpload(custody, bundle);
-    return custody;
-  }
-  function verifyReceipt(custody, body, receipt) {
-    assertLargeObjectContract(receipt, "encrypted-upload-receipt");
-    if (receipt.workspaceId !== custody.id || receipt.operationId !== body.operationId || receipt.revisionId !== body.manifest.revisionId || receipt.manifestSha256 !== sha256Hex(canonicalizeJson(body.manifest)) || receipt.version !== body.expectedVersion + 1)
-      throw new TypeError("Publication receipt differs from the saved operation.");
-    return receipt;
-  }
-  async function commitUpload(custody, body, options = {}) {
-    if (!options.readChunk)
-      throw new Error("Persist the exact upload spool before contacting the sharing service.");
-    const readChunk = options.readChunk;
-    const status = assertLargeObjectContract(
-      await request(custody, `/uploads/${body.operationId}`, { ...options, method: "PUT", body }),
-      "encrypted-upload-status"
-    );
-    const manifestSha256 = sha256Hex(canonicalizeJson(body.manifest));
-    if (status.workspaceId !== custody.id || status.operationId !== body.operationId || status.revisionId !== body.manifest.revisionId || status.manifestSha256 !== manifestSha256)
-      throw new TypeError("Upload status differs from the saved operation.");
-    if (status.status === "committed") return verifyReceipt(custody, body, status.receipt);
-    const received = /* @__PURE__ */ new Set();
-    for (const part of status.receivedChunks) {
-      const expected = body.manifest.chunks[part.index];
-      if (!expected || expected.byteLength !== part.byteLength || expected.sha256 !== part.sha256)
-        throw new TypeError("Uploaded chunk identity differs.");
-      received.add(part.index);
-    }
-    for (const part of body.manifest.chunks) {
-      if (received.has(part.index)) continue;
-      const bytes = await readChunk(part.index);
-      if (bytes.byteLength !== part.byteLength || await resourceSha256(bytes) !== part.sha256)
-        throw new TypeError("Saved upload chunk is corrupt.");
-      await request(custody, `/uploads/${body.operationId}/chunks/${part.index}`, {
-        ...options,
-        method: "PUT",
-        body: bytes,
-        binary: true,
-        limit: 65536
-      });
-    }
-    const commit = await legacy.signWorkspaceValue(
-      {
-        schemaVersion: "2.0.0",
-        workspaceId: custody.id,
-        operationId: body.operationId,
-        manifestSha256
-      },
-      custody.ownerPrivateKey
-    );
-    return verifyReceipt(
-      custody,
-      body,
-      await request(custody, `/uploads/${body.operationId}/commit`, {
-        ...options,
-        method: "POST",
-        body: commit
-      })
-    );
-  }
-  async function commitWorkspace(custody, options) {
-    if (!custody.pendingCreate) return getWorkspace(custody, options);
-    const receipt = await commitUpload(custody, custody.pendingCreate, options);
-    custody.version = receipt.version;
-    custody.currentRevision = receipt.revisionId;
-    delete custody.pendingCreate;
-    delete custody.spoolDirectory;
-    return receipt;
-  }
-  async function getWorkspace(access, options) {
-    const result = assertLargeObjectContract(
-      await request(access, "", options),
-      "encrypted-workspace-v2"
-    );
-    if (result.id !== access.id) throw new TypeError("Workspace identity differs.");
-    const ring = await unseal(
-      result.keyring,
-      await keyMaterial(access.token, access.id, "key-wrap"),
-      { type: "keyring", workspaceId: access.id, epoch: result.epoch }
-    );
-    if (canonicalizeJson(ring.ownerPublicKey) !== canonicalizeJson(result.ownerPublicKey) || access.ownerPublicKey && canonicalizeJson(access.ownerPublicKey) !== canonicalizeJson(result.ownerPublicKey) || !ring.keys?.[result.epoch] || Object.entries(ring.keys).some(
-      ([epoch, key]) => !/^[1-9][0-9]*$/u.test(epoch) || !tokenPattern.test(key)
-    ))
-      throw new TypeError("Workspace key history or owner identity differs.");
-    Object.assign(access, result, { keys: ring.keys });
-    return result;
-  }
-  async function openRevision(access, revisionId = access.currentRevision, options = {}) {
-    if (!access.keys) await getWorkspace(access, options);
-    if (!idPattern.test(revisionId)) throw new TypeError("Revision identity is invalid.");
-    const manifest = assertLargeObjectContract(
-      await request(access, `/revisions/${revisionId}/manifest`, {
-        ...options,
-        limit: LARGE_OBJECT_LIMITS.manifestBytes
-      }),
-      "encrypted-resource-manifest"
-    );
-    if (manifest.workspaceId !== access.id || manifest.revisionId !== revisionId || !access.keys[manifest.epoch])
-      throw new TypeError("Revision identity or key epoch differs.");
-    return openResourcePack(manifest, {
-      rawKey: decodeResourceBytes(access.keys[manifest.epoch], 32),
-      verify: (value) => legacy.verifyWorkspaceSignature(value, access.ownerPublicKey),
-      fetchChunk: (index) => request(access, `/revisions/${revisionId}/chunks/${index}`, {
-        ...options,
-        binary: true,
-        limit: LARGE_OBJECT_LIMITS.chunkBytes
-      })
-    });
-  }
-  async function decryptWorkspaceRevision(access, revisionId, options) {
-    const pack = await openRevision(access, revisionId, options);
-    try {
-      const bundle = assertBundle(await pack.loadBundle());
-      const reviewOf = digestBundle ? digestBundle(bundle) : legacy.workspaceEnvelopeDigest(digestInput(bundle));
-      if (pack.reviewOf !== void 0 && pack.reviewOf !== reviewOf)
-        throw new TypeError("Full review basis differs from authenticated catalog.");
-      return { ...bundle, workspaceRevision: revisionId ?? access.currentRevision, reviewOf };
-    } finally {
-      pack.dispose();
-    }
-  }
-  async function prepareWorkspaceMutation(custody, action, payload) {
-    if (custody.pendingCreate || custody.pendingMutation)
-      throw new Error("Retry the pending sharing operation before preparing another.");
-    if (action === "publish")
-      custody.pendingMutation = { action, body: await prepareUpload(custody, payload), next: {} };
-    else {
-      let body = {
-        operationId: legacy.newWorkspaceId(),
-        expectedVersion: custody.version,
-        epoch: custody.epoch
-      }, next = {};
-      if (action === "rotate") {
-        const token = legacy.newWorkspaceToken(), epoch = custody.epoch + 1, keys = { ...custody.keys, [epoch]: legacy.newWorkspaceToken() };
-        const keyring = await wrap(custody, token, epoch, keys);
-        body = {
-          ...body,
-          epoch,
-          reviewerAuthHash: sha256Hex(
-            await legacy.deriveWorkspaceAuthentication(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 sharing action.");
-      custody.pendingMutation = {
-        action,
-        body: await legacy.signWorkspaceValue(body, custody.ownerPrivateKey),
-        next
-      };
-    }
-    return custody.pendingMutation;
-  }
-  async function commitWorkspaceMutation(custody, options) {
-    const pending = custody.pendingMutation;
-    if (!pending) throw new Error("No sharing operation is pending.");
-    let result;
-    if (pending.action === "publish") result = await commitUpload(custody, pending.body, options);
-    else {
-      result = await request(custody, pending.action === "rotate" ? "/rotate" : "/manage", {
-        ...options,
-        method: "POST",
-        body: pending.body
-      });
-      if (pending.action === "delete") {
-        if (result.id !== custody.id || result.deleted !== true || result.schemaVersion !== "2.0.0" || Object.keys(result).some((key) => !["id", "deleted", "schemaVersion"].includes(key)))
-          throw new TypeError("Deletion receipt is invalid.");
-      } else {
-        assertLargeObjectContract(result, "encrypted-workspace-v2");
-        if (["pause", "resume"].includes(pending.action) && result.commentsPaused !== (pending.action === "pause"))
-          throw new TypeError("Management state differs.");
-        if (result.id !== custody.id || result.version !== pending.body.expectedVersion + 1 || result.epoch !== pending.body.epoch || result.currentRevision !== custody.currentRevision || canonicalizeJson(result.ownerPublicKey) !== canonicalizeJson(custody.ownerPublicKey) || canonicalizeJson(result.keyring) !== canonicalizeJson(pending.next.keyring ?? custody.keyring))
-          throw new TypeError("Management receipt is invalid.");
-      }
-    }
-    Object.assign(custody, pending.next, { version: pending.body.expectedVersion + 1 });
-    if (pending.action === "publish") {
-      custody.currentRevision = result.revisionId;
-      delete custody.spoolDirectory;
-    }
-    if (["pause", "resume"].includes(pending.action))
-      custody.commentsPaused = pending.action === "pause";
-    if (["revoke", "delete"].includes(pending.action))
-      custody.status = pending.action === "revoke" ? "revoked" : "deleted";
-    delete custody.pendingMutation;
-    return result;
-  }
-  async function prepareWorkspaceEvent(access, payload, { revisionId = access.currentRevision, reviewOf, signer } = {}) {
-    assertFeedback(payload);
-    if (!access.keys) throw new Error("Load the workspace before preparing feedback.");
-    signer ??= await legacy.createWorkspaceSigner();
-    const header = {
-      id: legacy.newWorkspaceId(),
-      epoch: access.epoch,
-      revisionId,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      authorPublicKey: signer.publicKey
-    };
-    const context = {
-      context: "openplanr.workspace-event.v2",
-      workspaceId: access.id,
-      id: header.id,
-      epoch: header.epoch,
-      revisionId
-    };
-    const event = await legacy.signWorkspaceValue(
-      {
-        ...header,
-        ...await seal(
-          { payload, reviewOf: reviewOf ?? payload.reviewOf },
-          decodeResourceBytes(access.keys[header.epoch], 32),
-          context,
-          LARGE_OBJECT_LIMITS.eventBytes
-        )
-      },
-      signer.privateKey
-    );
-    return assertLargeObjectContract(event, "encrypted-workspace-event-v2");
-  }
-  async function appendWorkspaceEvent(access, event, options) {
-    assertLargeObjectContract(event, "encrypted-workspace-event-v2");
-    const result = await request(access, "/events", { ...options, method: "POST", body: event });
-    if (result.id !== event.id || !Number.isSafeInteger(result.sequence) || result.sequence < 1)
-      throw new TypeError("Feedback receipt differs.");
-    return result;
-  }
-  async function readWorkspaceEvents(access, { after = 0, ...options } = {}) {
-    if (!Number.isSafeInteger(after) || after < 0) throw new TypeError("Invalid feedback cursor.");
-    if (!access.keys) await getWorkspace(access, options);
-    const page = await request(access, `/events?after=${after}`, {
-      ...options,
-      limit: LARGE_OBJECT_LIMITS.eventPageBytes
-    });
-    if (!Array.isArray(page.events) || page.events.length > LARGE_OBJECT_LIMITS.eventPageCount || !Number.isSafeInteger(page.cursor) || page.cursor < after || page.hasMore && page.cursor === after || typeof page.hasMore !== "boolean")
-      throw new TypeError("Feedback page is invalid.");
-    const events = [], issues = [];
-    let previous = after;
-    for (const entry of page.events) {
-      try {
-        const { sequence, ...event } = entry;
-        if (!Number.isSafeInteger(sequence) || sequence <= previous || sequence > page.cursor)
-          throw new TypeError("Feedback sequence is invalid.");
-        previous = sequence;
-        assertLargeObjectContract(event, "encrypted-workspace-event-v2");
-        if (!await legacy.verifyWorkspaceSignature(event, event.authorPublicKey) || !access.keys[event.epoch])
-          throw new TypeError("Feedback signature or key epoch is invalid.");
-        const value = await unseal(
-          event,
-          decodeResourceBytes(access.keys[event.epoch], 32),
-          {
-            context: "openplanr.workspace-event.v2",
-            workspaceId: access.id,
-            id: event.id,
-            epoch: event.epoch,
-            revisionId: event.revisionId
-          },
-          LARGE_OBJECT_LIMITS.eventBytes
-        );
-        assertFeedback(value.payload);
-        if (value.payload.reviewOf !== void 0 && value.payload.reviewOf !== value.reviewOf)
-          throw new TypeError("Feedback payload identity differs.");
-        if (!/^[a-f0-9]{64}$/u.test(value.reviewOf ?? ""))
-          throw new TypeError("Feedback review identity is invalid.");
-        events.push({
-          ...event,
-          publicKey: event.authorPublicKey,
-          sequence,
-          reviewOf: value.reviewOf,
-          payload: value.payload
-        });
-      } catch (error) {
-        issues.push({ id: entry.id, sequence: entry.sequence, reason: error.message });
-      }
-    }
-    return { ...page, events, issues };
-  }
-  return {
-    capabilities,
-    prepareWorkspace,
-    commitWorkspace,
-    getWorkspace,
-    openRevision,
-    decryptWorkspaceRevision,
-    listWorkspaceRevisions: (access, options) => request(access, "/revisions", options),
-    prepareWorkspaceMutation,
-    commitWorkspaceMutation,
-    prepareWorkspaceEvent,
-    appendWorkspaceEvent,
-    readWorkspaceEvents
-  };
-}
-
-// packages/artifact/lib/artifact/owner-custody.mjs
-import { randomBytes } from "node:crypto";
-import {
-  chmodSync,
-  closeSync,
-  existsSync,
-  fsyncSync,
-  linkSync,
-  lstatSync,
-  mkdirSync,
-  openSync,
-  readFileSync,
-  realpathSync,
-  renameSync,
-  unlinkSync,
-  writeFileSync
-} from "node:fs";
-import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
-function custodyError(message, code = "E_OWNER_CUSTODY_LOCATION") {
-  return Object.assign(new Error(message), { code, status: 400 });
-}
-function pathExists(path) {
-  try {
-    lstatSync(path);
-    return true;
-  } catch (error) {
-    if (error.code === "ENOENT") return false;
-    throw error;
-  }
-}
-function assertDirectoryAncestry(root, label) {
-  for (let path = root; dirname(path) !== path; path = dirname(path)) {
-    if (pathExists(path) && lstatSync(path).isSymbolicLink())
-      throw custodyError(`${label} custody directory must not contain symbolic links.`);
-  }
-}
-function assertPrivateFile(path, label) {
-  const stat = lstatSync(path);
-  if (!stat.isFile() || stat.isSymbolicLink() || process.platform !== "win32" && (stat.mode & 63 || stat.uid !== process.getuid()))
-    throw custodyError(
-      `${label} owner custody must be a private 0600 file.`,
-      "E_OWNER_CUSTODY_INVALID"
-    );
-}
-function physicalDirectoryPath(directory) {
-  let existing = resolve(directory);
-  const missing = [];
-  while (!existsSync(existing) && dirname(existing) !== existing) {
-    missing.unshift(basename(existing));
-    existing = dirname(existing);
-  }
-  return join(realpathSync(existing), ...missing);
-}
-function assertPrivateDirectory(root, label, recoveryOutput = false) {
-  const stat = lstatSync(root);
-  if (!stat.isDirectory() || stat.isSymbolicLink() || !recoveryOutput && process.platform !== "win32" && (stat.mode & 63 || stat.uid !== process.getuid()))
-    throw custodyError(`${label} custody must use a private local directory.`);
-}
-function ensurePrivateDirectory(root, { label = "Owner", recoveryOutput = false } = {}) {
-  if (recoveryOutput) root = physicalDirectoryPath(root);
-  assertDirectoryAncestry(root, label);
-  mkdirSync(root, { recursive: true, mode: 448 });
-  assertPrivateDirectory(root, label, recoveryOutput);
-}
-function readCustody(path, { label = "Owner", format, recoveryInput = false } = {}) {
-  if (recoveryInput && existsSync(path)) {
-    assertPrivateFile(path, label);
-    path = realpathSync(path);
-  }
-  assertDirectoryAncestry(dirname(path), label);
-  if (!pathExists(path)) return null;
-  assertPrivateDirectory(dirname(path), label, recoveryInput);
-  assertPrivateFile(path, label);
-  let record;
-  try {
-    record = JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    throw custodyError(`${label} owner custody is invalid.`, "E_OWNER_CUSTODY_INVALID");
-  }
-  if (record?.kind !== format || record.schemaVersion !== "1.0.0" || !record.custody)
-    throw custodyError(`${label} owner custody is invalid.`, "E_OWNER_CUSTODY_INVALID");
-  return record;
-}
-function writeCustody(path, record, { label = "Owner" } = {}) {
-  assertDirectoryAncestry(dirname(path), label);
-  assertPrivateDirectory(dirname(path), label);
-  if (existsSync(path)) assertPrivateFile(path, label);
-  const temp = `${path}.${randomBytes(8).toString("hex")}.tmp`;
-  const fd = openSync(temp, "wx", 384);
-  try {
-    writeFileSync(fd, `${JSON.stringify(record)}
-`);
-    fsyncSync(fd);
-  } finally {
-    closeSync(fd);
-  }
-  try {
-    renameSync(temp, path);
-    if (process.platform !== "win32") {
-      chmodSync(path, 384);
-      const directory = openSync(dirname(path), "r");
-      try {
-        fsyncSync(directory);
-      } finally {
-        closeSync(directory);
-      }
-    }
-  } catch (error) {
-    try {
-      unlinkSync(temp);
-    } catch {
-    }
-    throw error;
-  }
-}
-
-// packages/artifact/lib/artifact/upload-spool.mjs
-function privateRead(path, limit) {
-  const fd = openSync2(path, constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0));
-  try {
-    const stat = fstatSync(fd);
-    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > limit || process.platform !== "win32" && (stat.mode & 63 || stat.uid !== process.getuid()))
-      throw new TypeError("Upload spool must contain bounded private regular files.");
-    const bytes = new Uint8Array(Math.min(limit + 1, stat.size + 1));
-    let size = 0;
-    while (size < bytes.byteLength) {
-      const count = readSync(fd, bytes, size, bytes.byteLength - size, null);
-      if (!count) break;
-      size += count;
-    }
-    const after = fstatSync(fd);
-    if (size !== stat.size || after.size !== stat.size || after.mtimeMs !== stat.mtimeMs || after.ctimeMs !== stat.ctimeMs) {
-      throw new TypeError("Upload spool changed during its bounded private read.");
-    }
-    return bytes.subarray(0, size);
-  } finally {
-    closeSync2(fd);
-  }
-}
-function writePrivate(path, bytes) {
-  const fd = openSync2(
-    path,
-    constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | (constants2.O_NOFOLLOW ?? 0),
-    384
-  );
-  try {
-    writeFileSync2(fd, bytes);
-    fsyncSync2(fd);
-  } finally {
-    closeSync2(fd);
-  }
-}
-function readPreparedUploadRequest(directory) {
-  directory = resolve2(directory);
-  try {
-    lstatSync2(directory);
-  } catch (cause) {
-    const error = new TypeError("Prepared upload spool is missing or inaccessible.");
-    if (cause?.code === "ENOENT") error.code = "ENOENT";
-    throw error;
-  }
-  ensurePrivateDirectory(directory, { label: "Upload" });
-  try {
-    const body = JSON.parse(
-      new TextDecoder("utf-8", { fatal: true }).decode(
-        privateRead(join2(directory, "request.json"), 256 * 1024)
-      )
-    );
-    return assertLargeObjectContract(
-      body,
-      body?.manifest?.kind === "openplanr-company-resource-manifest" ? "company-resource-upload-prepare" : "encrypted-upload-prepare"
-    );
-  } catch (cause) {
-    const error = new TypeError("Prepared upload request is invalid or inaccessible.");
-    if (cause?.code === "ENOENT") error.code = "ENOENT";
-    throw error;
-  }
-}
-function spoolChunkReader(directory, body) {
-  assertLargeObjectContract(
-    body,
-    body?.manifest?.kind === "openplanr-company-resource-manifest" ? "company-resource-upload-prepare" : "encrypted-upload-prepare"
-  );
-  directory = resolve2(directory);
-  ensurePrivateDirectory(directory, { label: "Upload" });
-  const saved = readPreparedUploadRequest(directory);
-  if (canonicalizeJson(saved) !== canonicalizeJson(body))
-    throw new TypeError("Upload spool request differs from owner custody.");
-  return async (index) => {
-    const expected = body.manifest.chunks[index];
-    if (!expected || expected.index !== index) throw new TypeError("Invalid spool chunk index.");
-    const bytes = privateRead(join2(directory, `${index}.bin`), expected.byteLength);
-    if (bytes.byteLength !== expected.byteLength || await resourceSha256(bytes) !== expected.sha256)
-      throw new TypeError("Upload spool chunk is corrupt.");
-    return bytes;
-  };
-}
-var preparedUploadChunkReader = spoolChunkReader;
-async function persistPreparedUploadSpool(body, chunks, directory) {
-  assertLargeObjectContract(
-    body,
-    body?.manifest?.kind === "openplanr-company-resource-manifest" ? "company-resource-upload-prepare" : "encrypted-upload-prepare"
-  );
-  if (!Array.isArray(chunks) || chunks.length !== body.manifest.chunks.length)
-    throw new TypeError("Prepared upload chunk count differs.");
-  directory = resolve2(directory);
-  ensurePrivateDirectory(directory, { label: "Upload" });
-  for (const part of body.manifest.chunks) {
-    const path2 = join2(directory, `${part.index}.bin`), bytes = chunks[part.index];
-    if (!(bytes instanceof Uint8Array) || bytes.byteLength !== part.byteLength || await resourceSha256(bytes) !== part.sha256)
-      throw new TypeError("Prepared upload bytes differ.");
-    if (existsSync2(path2)) {
-      const existing = privateRead(path2, part.byteLength);
-      if (existing.byteLength !== part.byteLength || await resourceSha256(existing) !== part.sha256)
-        throw new TypeError("Existing upload spool will not be overwritten.");
-    } else writePrivate(path2, bytes);
-  }
-  const path = join2(directory, "request.json"), serialized = canonicalizeJson(body);
-  if (existsSync2(path)) {
-    if (new TextDecoder("utf-8", { fatal: true }).decode(privateRead(path, 256 * 1024)) !== serialized)
-      throw new TypeError("Existing spool request will not be overwritten.");
-  } else writePrivate(path, new TextEncoder().encode(serialized));
-  for (const ancestor of [directory, dirname2(directory)]) {
-    const fd = openSync2(ancestor, "r");
-    try {
-      fsyncSync2(fd);
-    } finally {
-      closeSync2(fd);
-    }
-  }
-  return directory;
-}
-async function persistUploadSpool(custody, root) {
-  const body = custody.pendingCreate ?? (custody.pendingMutation?.action === "publish" ? custody.pendingMutation.body : null);
-  if (!body) return;
-  if (custody.spoolDirectory) {
-    const reader = spoolChunkReader(custody.spoolDirectory, body);
-    for (const part of body.manifest.chunks) await reader(part.index);
-    return custody.spoolDirectory;
-  }
-  const chunks = uploadChunksFor(custody);
-  if (!chunks)
-    throw new TypeError("The pending upload has no durable spool; restore its recovery package.");
-  const directory = await persistPreparedUploadSpool(
-    body,
-    chunks,
-    join2(resolve2(root), custody.id, body.operationId)
-  );
-  for (let ancestor = dirname2(directory); ; ancestor = dirname2(ancestor)) {
-    const fd = openSync2(ancestor, "r");
-    try {
-      fsyncSync2(fd);
-    } finally {
-      closeSync2(fd);
-    }
-    if (ancestor === dirname2(resolve2(root))) break;
-  }
-  custody.spoolDirectory = directory;
-  return directory;
-}
-async function copyUploadSpool(custody, destination) {
-  const body = custody.pendingCreate ?? (custody.pendingMutation?.action === "publish" ? custody.pendingMutation.body : null);
-  if (!body) return null;
-  if (existsSync2(destination)) throw new TypeError("Recovery upload directory already exists.");
-  const reader = spoolChunkReader(custody.spoolDirectory, body);
-  ensurePrivateDirectory(destination, { label: "Recovery upload" });
-  for (const part of body.manifest.chunks)
-    writePrivate(join2(destination, `${part.index}.bin`), await reader(part.index));
-  writePrivate(join2(destination, "request.json"), new TextEncoder().encode(canonicalizeJson(body)));
-  const fd = openSync2(destination, "r");
-  try {
-    fsyncSync2(fd);
-  } finally {
-    closeSync2(fd);
-  }
-  return destination;
-}
-
 export {
-  ensurePrivateDirectory,
-  readCustody,
-  writeCustody,
-  createChunkedWorkspaceClient,
-  readPreparedUploadRequest,
-  spoolChunkReader,
-  preparedUploadChunkReader,
-  persistPreparedUploadSpool,
-  persistUploadSpool,
-  copyUploadSpool
+  deflateRaw_1,
+  Inflate_1
 };