@opengeni/artifact-tool 0.2.2

package/dist/chunk-72SYDU4O.js

@@ -0,0 +1,319 @@
+// src/bounded-zip.ts
+function parseBoundedZip(bytes, limits, fail) {
+  if (bytes.byteLength < 22) fail("invalid", "ZIP end record is missing");
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const end = findEndRecord(view, fail);
+  const disk = view.getUint16(end + 4, true);
+  const centralDisk = view.getUint16(end + 6, true);
+  const diskEntries = view.getUint16(end + 8, true);
+  const entryCount = view.getUint16(end + 10, true);
+  const centralSize = view.getUint32(end + 12, true);
+  const centralOffset = view.getUint32(end + 16, true);
+  if (disk !== 0 || centralDisk !== 0 || diskEntries !== entryCount) {
+    fail("unsupported", "Multi-disk ZIP archives are unsupported");
+  }
+  if (entryCount === 65535 || centralSize === 4294967295 || centralOffset === 4294967295) {
+    fail("unsupported", "ZIP64 archives are unsupported");
+  }
+  if (entryCount > limits.entries) fail("limit", "ZIP exceeds its entry limit");
+  if (centralOffset + centralSize !== end || centralOffset > bytes.byteLength) {
+    fail("invalid", "ZIP central-directory bounds are invalid");
+  }
+  if (end >= 20 && view.getUint32(end - 20, true) === 117853008) {
+    fail("unsupported", "ZIP64 archives are unsupported");
+  }
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  const names = /* @__PURE__ */ new Set();
+  const entries = [];
+  let offset = centralOffset;
+  let expandedBytes = 0;
+  let compressedBytes = 0;
+  for (let index = 0; index < entryCount; index += 1) {
+    ensureRange(bytes, offset, 46, fail, "ZIP central-directory entry");
+    if (view.getUint32(offset, true) !== 33639248) {
+      fail("invalid", "ZIP central-directory signature is invalid");
+    }
+    const flags = view.getUint16(offset + 8, true);
+    const compression = view.getUint16(offset + 10, true);
+    const checksum = view.getUint32(offset + 16, true);
+    const compressedSize = view.getUint32(offset + 20, true);
+    const expandedSize = view.getUint32(offset + 24, true);
+    const nameLength = view.getUint16(offset + 28, true);
+    const extraLength = view.getUint16(offset + 30, true);
+    const commentLength = view.getUint16(offset + 32, true);
+    const startDisk = view.getUint16(offset + 34, true);
+    const localHeaderOffset = view.getUint32(offset + 42, true);
+    const recordLength = 46 + nameLength + extraLength + commentLength;
+    ensureRange(bytes, offset, recordLength, fail, "ZIP central-directory entry");
+    if (offset + recordLength > centralOffset + centralSize) {
+      fail("invalid", "ZIP central-directory entry is out of bounds");
+    }
+    if (startDisk !== 0) fail("unsupported", "Multi-disk ZIP entries are unsupported");
+    if ((flags & 65) !== 0) fail("encrypted", "Encrypted ZIP entries are unsupported");
+    if ((flags & ~2062) !== 0 || compression === 0 && (flags & 6) !== 0) {
+      fail("unsupported", "ZIP entry flags are unsupported");
+    }
+    if (compression !== 0 && compression !== 8) {
+      fail("unsupported", `ZIP compression method ${compression} is unsupported`);
+    }
+    if (compressedSize === 4294967295 || expandedSize === 4294967295 || localHeaderOffset === 4294967295) {
+      fail("unsupported", "ZIP64 entries are unsupported");
+    }
+    rejectZip64Extra(
+      bytes.subarray(offset + 46 + nameLength, offset + 46 + nameLength + extraLength),
+      fail
+    );
+    let name;
+    try {
+      name = decoder.decode(bytes.subarray(offset + 46, offset + 46 + nameLength));
+    } catch {
+      fail("invalid", "ZIP entry name is not valid UTF-8");
+    }
+    validatePath(name, fail);
+    const collisionKey = name.normalize("NFC").toLowerCase();
+    if (names.has(collisionKey))
+      fail("invalid", "ZIP contains duplicate normalized entry names", name);
+    names.add(collisionKey);
+    if (compressedSize > limits.compressedEntryBytes)
+      fail("limit", "ZIP entry exceeds its compressed-size limit", name);
+    if (expandedSize > limits.expandedEntryBytes)
+      fail("limit", "ZIP entry exceeds its expanded-size limit", name);
+    if (compressedSize === 0 && expandedSize !== 0)
+      fail("invalid", "ZIP entry has impossible sizes", name);
+    if (expandedSize > (limits.compressionRatioThreshold ?? 0) && expandedSize / Math.max(1, compressedSize) > limits.compressionRatio)
+      fail("limit", "ZIP entry exceeds its compression-ratio limit", name);
+    expandedBytes += expandedSize;
+    compressedBytes += compressedSize;
+    if (expandedBytes > limits.expandedBytes) fail("limit", "ZIP exceeds its expanded-size limit");
+    if (expandedBytes > (limits.compressionRatioThreshold ?? 0) && expandedBytes / Math.max(1, compressedBytes) > limits.compressionRatio) {
+      fail("limit", "ZIP exceeds its aggregate compression-ratio limit", name);
+    }
+    const entry = localBounds(
+      bytes,
+      view,
+      decoder,
+      {
+        name,
+        flags,
+        compression,
+        checksum,
+        compressedSize,
+        expandedSize,
+        localHeaderOffset,
+        directory: name.endsWith("/")
+      },
+      centralOffset,
+      fail
+    );
+    entries.push(entry);
+    offset += recordLength;
+  }
+  if (offset !== centralOffset + centralSize)
+    fail("invalid", "ZIP central-directory size is inconsistent");
+  const localOrder = [...entries].sort(
+    (left, right) => left.localHeaderOffset - right.localHeaderOffset
+  );
+  for (let index = 1; index < localOrder.length; index += 1) {
+    const previous = localOrder[index - 1];
+    const current = localOrder[index];
+    if (previous.recordEnd > current.localHeaderOffset) {
+      fail("invalid", `ZIP local entries overlap: ${previous.name}`, current.name);
+    }
+  }
+  return entries;
+}
+async function consumeZipEntry(archive, entry, maximumBytes, fail, collect) {
+  if (entry.expandedSize > maximumBytes) {
+    fail("limit", "ZIP entry exceeds its configured expanded-size limit", entry.name);
+  }
+  const compressed = archive.subarray(entry.dataStart, entry.dataEnd);
+  if (entry.compression === 0) {
+    if (compressed.byteLength !== entry.expandedSize || zipCrc32(compressed) !== entry.checksum) {
+      fail("invalid", "ZIP entry failed size or checksum validation", entry.name);
+    }
+    return collect ? compressed.slice() : void 0;
+  }
+  if (typeof DecompressionStream === "undefined") {
+    return inflateWithNode(compressed, entry, fail, collect);
+  }
+  let stream;
+  try {
+    stream = new Blob([Uint8Array.from(compressed)]).stream().pipeThrough(new DecompressionStream("deflate-raw"));
+  } catch {
+    return inflateWithNode(compressed, entry, fail, collect);
+  }
+  const output = collect ? new Uint8Array(entry.expandedSize) : void 0;
+  const reader = stream.getReader();
+  let offset = 0;
+  let checksum = 4294967295;
+  try {
+    while (true) {
+      const result = await reader.read().catch(() => fail("invalid", "DEFLATE stream is invalid", entry.name));
+      if (result.done) break;
+      if (offset + result.value.byteLength > entry.expandedSize) {
+        await reader.cancel().catch(() => void 0);
+        fail("limit", "Inflated ZIP entry exceeds its declared or configured size", entry.name);
+      }
+      output?.set(result.value, offset);
+      offset += result.value.byteLength;
+      checksum = zipCrc32Update(checksum, result.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  if (offset !== entry.expandedSize || (checksum ^ 4294967295) >>> 0 !== entry.checksum) {
+    fail("invalid", "ZIP entry failed size or checksum validation", entry.name);
+  }
+  return output;
+}
+async function inflateWithNode(compressed, entry, fail, collect) {
+  if (typeof process === "undefined" || !process.versions?.node) {
+    fail("platform", "Raw DEFLATE is unavailable", entry.name);
+  }
+  try {
+    const { inflateRawSync } = await loadNodeZlib();
+    const output = inflateRawSync(compressed, { maxOutputLength: entry.expandedSize });
+    if (output.byteLength !== entry.expandedSize || zipCrc32(output) !== entry.checksum) {
+      fail("invalid", "ZIP entry failed size or checksum validation", entry.name);
+    }
+    return collect ? Uint8Array.from(output) : void 0;
+  } catch (error) {
+    if (error.code === "ERR_BUFFER_TOO_LARGE") {
+      fail("limit", "Inflated ZIP entry exceeds its declared or configured size", entry.name);
+    }
+    fail("invalid", "DEFLATE stream is invalid", entry.name);
+  }
+}
+async function loadNodeZlib() {
+  return importRuntimeModule("node:zlib");
+}
+function importRuntimeModule(specifier) {
+  return import(
+    /* @vite-ignore */
+    specifier
+  );
+}
+async function inflateBoundedZipEntry(archive, entry, maximumBytes, fail) {
+  return await consumeZipEntry(archive, entry, maximumBytes, fail, true);
+}
+async function verifyBoundedZipEntry(archive, entry, maximumBytes, fail) {
+  await consumeZipEntry(archive, entry, maximumBytes, fail, false);
+}
+function findEndRecord(view, fail) {
+  const minimum = Math.max(0, view.byteLength - 65557);
+  for (let offset = view.byteLength - 22; offset >= minimum; offset -= 1) {
+    if (view.getUint32(offset, true) === 101010256 && offset + 22 + view.getUint16(offset + 20, true) === view.byteLength)
+      return offset;
+  }
+  return fail("invalid", "ZIP end record is missing");
+}
+function localBounds(bytes, view, decoder, entry, centralOffset, fail) {
+  const header = entry.localHeaderOffset;
+  ensureRange(bytes, header, 30, fail, "ZIP local header", entry.name);
+  if (header + 30 > centralOffset || view.getUint32(header, true) !== 67324752) {
+    fail("invalid", "ZIP local-file header is invalid", entry.name);
+  }
+  const flags = view.getUint16(header + 6, true);
+  const compression = view.getUint16(header + 8, true);
+  if (flags !== entry.flags || compression !== entry.compression) {
+    fail("invalid", "ZIP local and central entry metadata disagree", entry.name);
+  }
+  const checksum = view.getUint32(header + 14, true);
+  const compressedSize = view.getUint32(header + 18, true);
+  const expandedSize = view.getUint32(header + 22, true);
+  const descriptor = (entry.flags & 8) !== 0;
+  if (!descriptor && (checksum !== entry.checksum || compressedSize !== entry.compressedSize || expandedSize !== entry.expandedSize) || descriptor && (checksum !== 0 && checksum !== entry.checksum || compressedSize !== 0 && compressedSize !== entry.compressedSize || expandedSize !== 0 && expandedSize !== entry.expandedSize))
+    fail("invalid", "ZIP local and central sizes or checksum disagree", entry.name);
+  const nameLength = view.getUint16(header + 26, true);
+  const extraLength = view.getUint16(header + 28, true);
+  const nameStart = header + 30;
+  const nameEnd = nameStart + nameLength;
+  ensureRange(
+    bytes,
+    header,
+    30 + nameLength + extraLength + entry.compressedSize,
+    fail,
+    "ZIP local entry",
+    entry.name
+  );
+  let localName;
+  try {
+    localName = decoder.decode(bytes.subarray(nameStart, nameEnd));
+  } catch {
+    fail("invalid", "ZIP local entry name is not valid UTF-8", entry.name);
+  }
+  if (localName !== entry.name)
+    fail("invalid", "ZIP local and central entry names disagree", entry.name);
+  const dataStart = nameEnd + extraLength;
+  const payloadEnd = dataStart + entry.compressedSize;
+  rejectZip64Extra(bytes.subarray(nameEnd, dataStart), fail, entry.name);
+  let recordEnd = payloadEnd;
+  if (descriptor) recordEnd = validateDescriptor(bytes, view, recordEnd, entry, fail);
+  if (dataStart < nameEnd || recordEnd > centralOffset) {
+    fail("invalid", "ZIP entry data is outside the local-file area", entry.name);
+  }
+  if (entry.directory && (entry.compressedSize !== 0 || entry.expandedSize !== 0)) {
+    fail("invalid", "ZIP directory entry contains data", entry.name);
+  }
+  return { ...entry, dataStart, dataEnd: payloadEnd, recordEnd };
+}
+function validateDescriptor(bytes, view, offset, entry, fail) {
+  ensureRange(bytes, offset, 12, fail, "ZIP data descriptor", entry.name);
+  const matches = (start) => start + 12 <= bytes.byteLength && view.getUint32(start, true) === entry.checksum && view.getUint32(start + 4, true) === entry.compressedSize && view.getUint32(start + 8, true) === entry.expandedSize;
+  if (matches(offset)) return offset + 12;
+  if (view.getUint32(offset, true) === 134695760 && matches(offset + 4)) return offset + 16;
+  return fail("invalid", "ZIP data descriptor disagrees with central directory", entry.name);
+}
+function rejectZip64Extra(extra, fail, entryName) {
+  const view = new DataView(extra.buffer, extra.byteOffset, extra.byteLength);
+  let offset = 0;
+  while (offset < extra.byteLength) {
+    if (offset + 4 > extra.byteLength) fail("invalid", "ZIP extra field is malformed", entryName);
+    const id = view.getUint16(offset, true);
+    const size = view.getUint16(offset + 2, true);
+    if (offset + 4 + size > extra.byteLength)
+      fail("invalid", "ZIP extra field is malformed", entryName);
+    if (id === 1) fail("unsupported", "ZIP64 entries are unsupported", entryName);
+    offset += 4 + size;
+  }
+}
+function validatePath(name, fail) {
+  if (name.length === 0 || name.length > 1024 || /[\u0000-\u001f\u007f]/.test(name) || name.includes("\\") || name.startsWith("/") || /^[A-Za-z]:/.test(name) || /%(?:2e|2f|5c)/i.test(name))
+    fail("invalid", "ZIP entry path is unsafe", name);
+  const segments = name.split("/");
+  if (segments.some(
+    (segment, index) => segment === "." || segment === ".." || segment === "" && index !== segments.length - 1
+  )) {
+    fail("invalid", "ZIP entry path is unsafe", name);
+  }
+}
+function ensureRange(bytes, offset, length, fail, description, entryName) {
+  if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || offset + length > bytes.byteLength) {
+    fail("invalid", `${description} is out of bounds`, entryName);
+  }
+}
+var crcTable;
+function zipCrc32Update(initial, bytes) {
+  if (!crcTable) {
+    crcTable = new Uint32Array(256);
+    for (let index = 0; index < 256; index += 1) {
+      let value2 = index;
+      for (let bit = 0; bit < 8; bit += 1)
+        value2 = (value2 & 1) !== 0 ? 3988292384 ^ value2 >>> 1 : value2 >>> 1;
+      crcTable[index] = value2 >>> 0;
+    }
+  }
+  let value = initial;
+  for (const byte of bytes) value = (crcTable[(value ^ byte) & 255] ?? 0) ^ value >>> 8;
+  return value >>> 0;
+}
+function zipCrc32(bytes) {
+  return (zipCrc32Update(4294967295, bytes) ^ 4294967295) >>> 0;
+}
+
+export {
+  parseBoundedZip,
+  inflateBoundedZipEntry,
+  verifyBoundedZipEntry
+};
+//# sourceMappingURL=chunk-72SYDU4O.js.map

package/dist/chunk-72SYDU4O.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bounded-zip.ts"],"sourcesContent":["export type BoundedZipEntry = {\n  name: string;\n  flags: number;\n  compression: 0 | 8;\n  checksum: number;\n  compressedSize: number;\n  expandedSize: number;\n  localHeaderOffset: number;\n  dataStart: number;\n  dataEnd: number;\n  recordEnd: number;\n  directory: boolean;\n};\n\nexport type BoundedZipLimits = {\n  entries: number;\n  compressedEntryBytes: number;\n  expandedEntryBytes: number;\n  expandedBytes: number;\n  compressionRatio: number;\n  compressionRatioThreshold?: number;\n};\n\nexport type BoundedZipFailure = (\n  kind: \"invalid\" | \"unsupported\" | \"encrypted\" | \"limit\" | \"platform\",\n  message: string,\n  entryName?: string,\n) => never;\n\n/** Parses ZIP metadata and validates every local record without inflating payloads. */\nexport function parseBoundedZip(\n  bytes: Uint8Array,\n  limits: BoundedZipLimits,\n  fail: BoundedZipFailure,\n): BoundedZipEntry[] {\n  if (bytes.byteLength < 22) fail(\"invalid\", \"ZIP end record is missing\");\n  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n  const end = findEndRecord(view, fail);\n  const disk = view.getUint16(end + 4, true);\n  const centralDisk = view.getUint16(end + 6, true);\n  const diskEntries = view.getUint16(end + 8, true);\n  const entryCount = view.getUint16(end + 10, true);\n  const centralSize = view.getUint32(end + 12, true);\n  const centralOffset = view.getUint32(end + 16, true);\n  if (disk !== 0 || centralDisk !== 0 || diskEntries !== entryCount) {\n    fail(\"unsupported\", \"Multi-disk ZIP archives are unsupported\");\n  }\n  if (entryCount === 0xffff || centralSize === 0xffffffff || centralOffset === 0xffffffff) {\n    fail(\"unsupported\", \"ZIP64 archives are unsupported\");\n  }\n  if (entryCount > limits.entries) fail(\"limit\", \"ZIP exceeds its entry limit\");\n  if (centralOffset + centralSize !== end || centralOffset > bytes.byteLength) {\n    fail(\"invalid\", \"ZIP central-directory bounds are invalid\");\n  }\n  if (end >= 20 && view.getUint32(end - 20, true) === 0x07064b50) {\n    fail(\"unsupported\", \"ZIP64 archives are unsupported\");\n  }\n\n  const decoder = new TextDecoder(\"utf-8\", { fatal: true });\n  const names = new Set<string>();\n  const entries: BoundedZipEntry[] = [];\n  let offset = centralOffset;\n  let expandedBytes = 0;\n  let compressedBytes = 0;\n  for (let index = 0; index < entryCount; index += 1) {\n    ensureRange(bytes, offset, 46, fail, \"ZIP central-directory entry\");\n    if (view.getUint32(offset, true) !== 0x02014b50) {\n      fail(\"invalid\", \"ZIP central-directory signature is invalid\");\n    }\n    const flags = view.getUint16(offset + 8, true);\n    const compression = view.getUint16(offset + 10, true);\n    const checksum = view.getUint32(offset + 16, true);\n    const compressedSize = view.getUint32(offset + 20, true);\n    const expandedSize = view.getUint32(offset + 24, true);\n    const nameLength = view.getUint16(offset + 28, true);\n    const extraLength = view.getUint16(offset + 30, true);\n    const commentLength = view.getUint16(offset + 32, true);\n    const startDisk = view.getUint16(offset + 34, true);\n    const localHeaderOffset = view.getUint32(offset + 42, true);\n    const recordLength = 46 + nameLength + extraLength + commentLength;\n    ensureRange(bytes, offset, recordLength, fail, \"ZIP central-directory entry\");\n    if (offset + recordLength > centralOffset + centralSize) {\n      fail(\"invalid\", \"ZIP central-directory entry is out of bounds\");\n    }\n    if (startDisk !== 0) fail(\"unsupported\", \"Multi-disk ZIP entries are unsupported\");\n    if ((flags & 0x0041) !== 0) fail(\"encrypted\", \"Encrypted ZIP entries are unsupported\");\n    if ((flags & ~0x080e) !== 0 || (compression === 0 && (flags & 0x0006) !== 0)) {\n      fail(\"unsupported\", \"ZIP entry flags are unsupported\");\n    }\n    if (compression !== 0 && compression !== 8) {\n      fail(\"unsupported\", `ZIP compression method ${compression} is unsupported`);\n    }\n    if (\n      compressedSize === 0xffffffff ||\n      expandedSize === 0xffffffff ||\n      localHeaderOffset === 0xffffffff\n    ) {\n      fail(\"unsupported\", \"ZIP64 entries are unsupported\");\n    }\n    rejectZip64Extra(\n      bytes.subarray(offset + 46 + nameLength, offset + 46 + nameLength + extraLength),\n      fail,\n    );\n    let name: string;\n    try {\n      name = decoder.decode(bytes.subarray(offset + 46, offset + 46 + nameLength));\n    } catch {\n      fail(\"invalid\", \"ZIP entry name is not valid UTF-8\");\n    }\n    validatePath(name, fail);\n    const collisionKey = name.normalize(\"NFC\").toLowerCase();\n    if (names.has(collisionKey))\n      fail(\"invalid\", \"ZIP contains duplicate normalized entry names\", name);\n    names.add(collisionKey);\n    if (compressedSize > limits.compressedEntryBytes)\n      fail(\"limit\", \"ZIP entry exceeds its compressed-size limit\", name);\n    if (expandedSize > limits.expandedEntryBytes)\n      fail(\"limit\", \"ZIP entry exceeds its expanded-size limit\", name);\n    if (compressedSize === 0 && expandedSize !== 0)\n      fail(\"invalid\", \"ZIP entry has impossible sizes\", name);\n    if (\n      expandedSize > (limits.compressionRatioThreshold ?? 0) &&\n      expandedSize / Math.max(1, compressedSize) > limits.compressionRatio\n    )\n      fail(\"limit\", \"ZIP entry exceeds its compression-ratio limit\", name);\n    expandedBytes += expandedSize;\n    compressedBytes += compressedSize;\n    if (expandedBytes > limits.expandedBytes) fail(\"limit\", \"ZIP exceeds its expanded-size limit\");\n    if (\n      expandedBytes > (limits.compressionRatioThreshold ?? 0) &&\n      expandedBytes / Math.max(1, compressedBytes) > limits.compressionRatio\n    ) {\n      fail(\"limit\", \"ZIP exceeds its aggregate compression-ratio limit\", name);\n    }\n\n    const entry = localBounds(\n      bytes,\n      view,\n      decoder,\n      {\n        name,\n        flags,\n        compression,\n        checksum,\n        compressedSize,\n        expandedSize,\n        localHeaderOffset,\n        directory: name.endsWith(\"/\"),\n      },\n      centralOffset,\n      fail,\n    );\n    entries.push(entry);\n    offset += recordLength;\n  }\n  if (offset !== centralOffset + centralSize)\n    fail(\"invalid\", \"ZIP central-directory size is inconsistent\");\n  const localOrder = [...entries].sort(\n    (left, right) => left.localHeaderOffset - right.localHeaderOffset,\n  );\n  for (let index = 1; index < localOrder.length; index += 1) {\n    const previous = localOrder[index - 1]!;\n    const current = localOrder[index]!;\n    if (previous.recordEnd > current.localHeaderOffset) {\n      fail(\"invalid\", `ZIP local entries overlap: ${previous.name}`, current.name);\n    }\n  }\n  return entries;\n}\n\nasync function consumeZipEntry(\n  archive: Uint8Array,\n  entry: BoundedZipEntry,\n  maximumBytes: number,\n  fail: BoundedZipFailure,\n  collect: boolean,\n): Promise<Uint8Array | undefined> {\n  if (entry.expandedSize > maximumBytes) {\n    fail(\"limit\", \"ZIP entry exceeds its configured expanded-size limit\", entry.name);\n  }\n  const compressed = archive.subarray(entry.dataStart, entry.dataEnd);\n  if (entry.compression === 0) {\n    if (compressed.byteLength !== entry.expandedSize || zipCrc32(compressed) !== entry.checksum) {\n      fail(\"invalid\", \"ZIP entry failed size or checksum validation\", entry.name);\n    }\n    return collect ? compressed.slice() : undefined;\n  }\n  if (typeof DecompressionStream === \"undefined\") {\n    return inflateWithNode(compressed, entry, fail, collect);\n  }\n  let stream: ReadableStream<Uint8Array>;\n  try {\n    stream = new Blob([Uint8Array.from(compressed)])\n      .stream()\n      .pipeThrough(new DecompressionStream(\"deflate-raw\"));\n  } catch {\n    return inflateWithNode(compressed, entry, fail, collect);\n  }\n  const output = collect ? new Uint8Array(entry.expandedSize) : undefined;\n  const reader = stream.getReader();\n  let offset = 0;\n  let checksum = 0xffffffff;\n  try {\n    while (true) {\n      const result = await reader\n        .read()\n        .catch(() => fail(\"invalid\", \"DEFLATE stream is invalid\", entry.name));\n      if (result.done) break;\n      if (offset + result.value.byteLength > entry.expandedSize) {\n        await reader.cancel().catch(() => undefined);\n        fail(\"limit\", \"Inflated ZIP entry exceeds its declared or configured size\", entry.name);\n      }\n      output?.set(result.value, offset);\n      offset += result.value.byteLength;\n      checksum = zipCrc32Update(checksum, result.value);\n    }\n  } finally {\n    reader.releaseLock();\n  }\n  if (offset !== entry.expandedSize || (checksum ^ 0xffffffff) >>> 0 !== entry.checksum) {\n    fail(\"invalid\", \"ZIP entry failed size or checksum validation\", entry.name);\n  }\n  return output;\n}\n\nasync function inflateWithNode(\n  compressed: Uint8Array,\n  entry: BoundedZipEntry,\n  fail: BoundedZipFailure,\n  collect: boolean,\n): Promise<Uint8Array | undefined> {\n  if (typeof process === \"undefined\" || !process.versions?.node) {\n    fail(\"platform\", \"Raw DEFLATE is unavailable\", entry.name);\n  }\n  try {\n    const { inflateRawSync } = await loadNodeZlib();\n    const output = inflateRawSync(compressed, { maxOutputLength: entry.expandedSize });\n    if (output.byteLength !== entry.expandedSize || zipCrc32(output) !== entry.checksum) {\n      fail(\"invalid\", \"ZIP entry failed size or checksum validation\", entry.name);\n    }\n    return collect ? Uint8Array.from(output) : undefined;\n  } catch (error) {\n    if ((error as { code?: string }).code === \"ERR_BUFFER_TOO_LARGE\") {\n      fail(\"limit\", \"Inflated ZIP entry exceeds its declared or configured size\", entry.name);\n    }\n    fail(\"invalid\", \"DEFLATE stream is invalid\", entry.name);\n  }\n}\n\nasync function loadNodeZlib(): Promise<typeof import(\"node:zlib\")> {\n  // Literal dynamic imports are still resolved and polyfilled by browser\n  // bundlers. Keep the fallback available to Node/Bun without granting the\n  // browser codec graph an eager Node compatibility closure.\n  return importRuntimeModule<typeof import(\"node:zlib\")>(\"node:zlib\");\n}\n\nfunction importRuntimeModule<T>(specifier: string): Promise<T> {\n  return import(/* @vite-ignore */ specifier) as Promise<T>;\n}\n\nexport async function inflateBoundedZipEntry(\n  archive: Uint8Array,\n  entry: BoundedZipEntry,\n  maximumBytes: number,\n  fail: BoundedZipFailure,\n): Promise<Uint8Array> {\n  return (await consumeZipEntry(archive, entry, maximumBytes, fail, true))!;\n}\n\nexport async function verifyBoundedZipEntry(\n  archive: Uint8Array,\n  entry: BoundedZipEntry,\n  maximumBytes: number,\n  fail: BoundedZipFailure,\n): Promise<void> {\n  await consumeZipEntry(archive, entry, maximumBytes, fail, false);\n}\n\nfunction findEndRecord(view: DataView, fail: BoundedZipFailure): number {\n  const minimum = Math.max(0, view.byteLength - 65_557);\n  for (let offset = view.byteLength - 22; offset >= minimum; offset -= 1) {\n    if (\n      view.getUint32(offset, true) === 0x06054b50 &&\n      offset + 22 + view.getUint16(offset + 20, true) === view.byteLength\n    )\n      return offset;\n  }\n  return fail(\"invalid\", \"ZIP end record is missing\");\n}\n\nfunction localBounds(\n  bytes: Uint8Array,\n  view: DataView,\n  decoder: TextDecoder,\n  entry: Omit<BoundedZipEntry, \"dataStart\" | \"dataEnd\" | \"recordEnd\">,\n  centralOffset: number,\n  fail: BoundedZipFailure,\n): BoundedZipEntry {\n  const header = entry.localHeaderOffset;\n  ensureRange(bytes, header, 30, fail, \"ZIP local header\", entry.name);\n  if (header + 30 > centralOffset || view.getUint32(header, true) !== 0x04034b50) {\n    fail(\"invalid\", \"ZIP local-file header is invalid\", entry.name);\n  }\n  const flags = view.getUint16(header + 6, true);\n  const compression = view.getUint16(header + 8, true);\n  if (flags !== entry.flags || compression !== entry.compression) {\n    fail(\"invalid\", \"ZIP local and central entry metadata disagree\", entry.name);\n  }\n  const checksum = view.getUint32(header + 14, true);\n  const compressedSize = view.getUint32(header + 18, true);\n  const expandedSize = view.getUint32(header + 22, true);\n  const descriptor = (entry.flags & 0x0008) !== 0;\n  if (\n    (!descriptor &&\n      (checksum !== entry.checksum ||\n        compressedSize !== entry.compressedSize ||\n        expandedSize !== entry.expandedSize)) ||\n    (descriptor &&\n      ((checksum !== 0 && checksum !== entry.checksum) ||\n        (compressedSize !== 0 && compressedSize !== entry.compressedSize) ||\n        (expandedSize !== 0 && expandedSize !== entry.expandedSize)))\n  )\n    fail(\"invalid\", \"ZIP local and central sizes or checksum disagree\", entry.name);\n  const nameLength = view.getUint16(header + 26, true);\n  const extraLength = view.getUint16(header + 28, true);\n  const nameStart = header + 30;\n  const nameEnd = nameStart + nameLength;\n  ensureRange(\n    bytes,\n    header,\n    30 + nameLength + extraLength + entry.compressedSize,\n    fail,\n    \"ZIP local entry\",\n    entry.name,\n  );\n  let localName: string;\n  try {\n    localName = decoder.decode(bytes.subarray(nameStart, nameEnd));\n  } catch {\n    fail(\"invalid\", \"ZIP local entry name is not valid UTF-8\", entry.name);\n  }\n  if (localName !== entry.name)\n    fail(\"invalid\", \"ZIP local and central entry names disagree\", entry.name);\n  const dataStart = nameEnd + extraLength;\n  const payloadEnd = dataStart + entry.compressedSize;\n  rejectZip64Extra(bytes.subarray(nameEnd, dataStart), fail, entry.name);\n  let recordEnd = payloadEnd;\n  if (descriptor) recordEnd = validateDescriptor(bytes, view, recordEnd, entry, fail);\n  if (dataStart < nameEnd || recordEnd > centralOffset) {\n    fail(\"invalid\", \"ZIP entry data is outside the local-file area\", entry.name);\n  }\n  if (entry.directory && (entry.compressedSize !== 0 || entry.expandedSize !== 0)) {\n    fail(\"invalid\", \"ZIP directory entry contains data\", entry.name);\n  }\n  return { ...entry, dataStart, dataEnd: payloadEnd, recordEnd };\n}\n\nfunction validateDescriptor(\n  bytes: Uint8Array,\n  view: DataView,\n  offset: number,\n  entry: Omit<BoundedZipEntry, \"dataStart\" | \"dataEnd\" | \"recordEnd\">,\n  fail: BoundedZipFailure,\n): number {\n  ensureRange(bytes, offset, 12, fail, \"ZIP data descriptor\", entry.name);\n  const matches = (start: number): boolean =>\n    start + 12 <= bytes.byteLength &&\n    view.getUint32(start, true) === entry.checksum &&\n    view.getUint32(start + 4, true) === entry.compressedSize &&\n    view.getUint32(start + 8, true) === entry.expandedSize;\n  if (matches(offset)) return offset + 12;\n  if (view.getUint32(offset, true) === 0x08074b50 && matches(offset + 4)) return offset + 16;\n  return fail(\"invalid\", \"ZIP data descriptor disagrees with central directory\", entry.name);\n}\n\nfunction rejectZip64Extra(extra: Uint8Array, fail: BoundedZipFailure, entryName?: string): void {\n  const view = new DataView(extra.buffer, extra.byteOffset, extra.byteLength);\n  let offset = 0;\n  while (offset < extra.byteLength) {\n    if (offset + 4 > extra.byteLength) fail(\"invalid\", \"ZIP extra field is malformed\", entryName);\n    const id = view.getUint16(offset, true);\n    const size = view.getUint16(offset + 2, true);\n    if (offset + 4 + size > extra.byteLength)\n      fail(\"invalid\", \"ZIP extra field is malformed\", entryName);\n    if (id === 0x0001) fail(\"unsupported\", \"ZIP64 entries are unsupported\", entryName);\n    offset += 4 + size;\n  }\n}\n\nfunction validatePath(name: string, fail: BoundedZipFailure): void {\n  if (\n    name.length === 0 ||\n    name.length > 1_024 ||\n    /[\\u0000-\\u001f\\u007f]/.test(name) ||\n    name.includes(\"\\\\\") ||\n    name.startsWith(\"/\") ||\n    /^[A-Za-z]:/.test(name) ||\n    /%(?:2e|2f|5c)/i.test(name)\n  )\n    fail(\"invalid\", \"ZIP entry path is unsafe\", name);\n  const segments = name.split(\"/\");\n  if (\n    segments.some(\n      (segment, index) =>\n        segment === \".\" || segment === \"..\" || (segment === \"\" && index !== segments.length - 1),\n    )\n  ) {\n    fail(\"invalid\", \"ZIP entry path is unsafe\", name);\n  }\n}\n\nfunction ensureRange(\n  bytes: Uint8Array,\n  offset: number,\n  length: number,\n  fail: BoundedZipFailure,\n  description: string,\n  entryName?: string,\n): void {\n  if (\n    !Number.isSafeInteger(offset) ||\n    !Number.isSafeInteger(length) ||\n    offset < 0 ||\n    length < 0 ||\n    offset + length > bytes.byteLength\n  ) {\n    fail(\"invalid\", `${description} is out of bounds`, entryName);\n  }\n}\n\nlet crcTable: Uint32Array | undefined;\n\nexport function zipCrc32Update(initial: number, bytes: Uint8Array): number {\n  if (!crcTable) {\n    crcTable = new Uint32Array(256);\n    for (let index = 0; index < 256; index += 1) {\n      let value = index;\n      for (let bit = 0; bit < 8; bit += 1)\n        value = (value & 1) !== 0 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;\n      crcTable[index] = value >>> 0;\n    }\n  }\n  let value = initial;\n  for (const byte of bytes) value = (crcTable[(value ^ byte) & 0xff] ?? 0) ^ (value >>> 8);\n  return value >>> 0;\n}\n\nexport function zipCrc32(bytes: Uint8Array): number {\n  return (zipCrc32Update(0xffffffff, bytes) ^ 0xffffffff) >>> 0;\n}\n"],"mappings":"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","names":["value"]}

package/dist/chunk-B2ZJRZDA.js

@@ -0,0 +1,279 @@
+import {
+  ArtifactRuntimeError
+} from "./chunk-N2IHNWBS.js";
+
+// src/native.ts
+import {
+  EDITABLE_ARTIFACT_INTENT_VERSION,
+  SPREADSHEET_ARTIFACT_COMMAND_VERSION,
+  assertCanonicalSpreadsheetArtifactCommandBytes,
+  decodeEditableArtifactMutationIntent,
+  encodeEditableArtifactMutationIntent,
+  encodeSpreadsheetArtifactCommandBatch,
+  hashEditableArtifactMutationIntentBytes
+} from "@opengeni/contracts/editable-artifacts";
+import {
+  SPREADSHEET_ARTIFACT_COMMAND_VERSION as SPREADSHEET_ARTIFACT_COMMAND_VERSION2,
+  assertCanonicalSpreadsheetArtifactCommandBytes as assertCanonicalSpreadsheetArtifactCommandBytes2,
+  decodeSpreadsheetArtifactCommandBatch,
+  editableArtifactStableId,
+  encodeSpreadsheetArtifactCommandBatch as encodeSpreadsheetArtifactCommandBatch2,
+  spreadsheetSheetId
+} from "@opengeni/contracts/editable-artifacts";
+var NativeSpreadsheetSession = class _NativeSpreadsheetSession {
+  constructor(runtime, session) {
+    this.runtime = runtime;
+    this.session = session;
+    requireNativeSpreadsheetRuntime(runtime);
+    this.target = runtime.target;
+    this.capabilities = runtime.capabilities;
+    this.buildIdentity = runtime.buildIdentity;
+  }
+  kind = "native";
+  modality = "spreadsheet";
+  target;
+  capabilities;
+  buildIdentity;
+  static create(runtime, replicaNamespace) {
+    requireNativeSpreadsheetRuntime(runtime);
+    return new _NativeSpreadsheetSession(
+      runtime,
+      runtime.createCollaborationSession(replicaNamespace)
+    );
+  }
+  static open(runtime, snapshot) {
+    requireNativeSpreadsheetRuntime(runtime);
+    return new _NativeSpreadsheetSession(runtime, runtime.openCollaborationSession(snapshot));
+  }
+  /**
+   * Authors one already-canonical mutation. Rust independently validates the
+   * exact OGATX/OGASC bytes, resolves typed operations, applies atomically, and
+   * returns the whole canonical OGACO transaction.
+   */
+  authorTransaction(intentBytes, resolvedBaseBytes) {
+    assertSpreadsheetIntent(intentBytes);
+    return this.session.authorTransaction(intentBytes, resolvedBaseBytes);
+  }
+  /** Encodes one identity-free typed command batch and authors it atomically. */
+  authorCommands(input) {
+    const commandBytes = encodeSpreadsheetArtifactCommandBatch(input.commands);
+    const intentBytes = encodeEditableArtifactMutationIntent({
+      ...input.intent,
+      envelopeVersion: EDITABLE_ARTIFACT_INTENT_VERSION,
+      protocolVersion: 1,
+      modelSchemaVersion: 1,
+      commandProtocolVersion: SPREADSHEET_ARTIFACT_COMMAND_VERSION,
+      commandBytes
+    });
+    const requestHash = hashEditableArtifactMutationIntentBytes(intentBytes);
+    const committedTransactionBytes = this.authorTransaction(intentBytes, input.resolvedBaseBytes);
+    return Object.freeze({ intentBytes, requestHash, committedTransactionBytes });
+  }
+  /** Replays one whole authoritative OGACO transaction atomically. */
+  applyCommitted(committedTransactionBytes) {
+    this.session.applyCommitted(committedTransactionBytes);
+  }
+  /**
+   * Executes one canonical OGAKQ request. Typed viewport/metadata helpers use
+   * the shared contract codec; this raw method remains useful at server byte
+   * boundaries and never exposes a Rust object layout.
+   */
+  query(queryBytes) {
+    return this.session.query(queryBytes);
+  }
+  snapshot() {
+    return this.session.snapshot();
+  }
+  frontier() {
+    return this.session.frontier();
+  }
+  stateHash() {
+    return this.session.stateHash();
+  }
+  revision() {
+    return this.session.revision();
+  }
+  fork() {
+    return new _NativeSpreadsheetSession(this.runtime, this.session.fork());
+  }
+  isClosed() {
+    return this.session.isClosed();
+  }
+  dispose() {
+    this.session.dispose();
+  }
+};
+var NativeDocumentSession = class _NativeDocumentSession {
+  constructor(runtime, session) {
+    this.runtime = runtime;
+    this.session = session;
+    requireNativeRuntime(runtime);
+    this.target = runtime.target;
+    this.capabilities = runtime.capabilities;
+    this.buildIdentity = runtime.buildIdentity;
+  }
+  kind = "native";
+  modality = "document";
+  target;
+  capabilities;
+  buildIdentity;
+  static create(runtime, namespace) {
+    requireNativeRuntime(runtime);
+    return new _NativeDocumentSession(runtime, runtime.createDocumentSession(namespace));
+  }
+  static open(runtime, snapshot) {
+    requireNativeRuntime(runtime);
+    return new _NativeDocumentSession(runtime, runtime.openDocumentSession(snapshot));
+  }
+  applyCommands(commands) {
+    return this.session.applyCommands(commands);
+  }
+  query(request) {
+    return this.session.query(request);
+  }
+  snapshot() {
+    return this.session.snapshot();
+  }
+  revision() {
+    return this.session.revision();
+  }
+  stateHash() {
+    return this.session.stateHash();
+  }
+  fork() {
+    return new _NativeDocumentSession(this.runtime, this.session.fork());
+  }
+  isClosed() {
+    return this.session.isClosed();
+  }
+  dispose() {
+    this.session.dispose();
+  }
+};
+var NativePresentationSession = class _NativePresentationSession {
+  constructor(runtime, session) {
+    this.runtime = runtime;
+    this.session = session;
+    requireNativeRuntime(runtime);
+    this.target = runtime.target;
+    this.capabilities = runtime.capabilities;
+    this.buildIdentity = runtime.buildIdentity;
+  }
+  kind = "native";
+  modality = "presentation";
+  target;
+  capabilities;
+  buildIdentity;
+  static create(runtime, namespace) {
+    requireNativeRuntime(runtime);
+    return new _NativePresentationSession(runtime, runtime.createPresentationSession(namespace));
+  }
+  static open(runtime, snapshot) {
+    requireNativeRuntime(runtime);
+    return new _NativePresentationSession(runtime, runtime.openPresentationSession(snapshot));
+  }
+  applyCommands(commands) {
+    return this.session.applyCommands(commands);
+  }
+  query(request) {
+    return this.session.query(request);
+  }
+  snapshot() {
+    return this.session.snapshot();
+  }
+  revision() {
+    return this.session.revision();
+  }
+  stateHash() {
+    return this.session.stateHash();
+  }
+  fork() {
+    return new _NativePresentationSession(this.runtime, this.session.fork());
+  }
+  isClosed() {
+    return this.session.isClosed();
+  }
+  dispose() {
+    this.session.dispose();
+  }
+};
+var NativeTextLayoutSession = class _NativeTextLayoutSession {
+  constructor(session, runtime) {
+    this.session = session;
+    requireNativeRuntime(runtime);
+    this.target = runtime.target;
+    this.capabilities = runtime.capabilities;
+    this.buildIdentity = runtime.buildIdentity;
+  }
+  kind = "native";
+  modality = "text-layout";
+  target;
+  capabilities;
+  buildIdentity;
+  static open(runtime, fontBundle) {
+    requireNativeRuntime(runtime);
+    return new _NativeTextLayoutSession(runtime.openTextLayoutSession(fontBundle), runtime);
+  }
+  layout(request) {
+    return this.session.layout(request);
+  }
+  isClosed() {
+    return this.session.isClosed();
+  }
+  dispose() {
+    this.session.dispose();
+  }
+};
+function createNativeArtifactSession(runtime, input) {
+  if (input.modality === "spreadsheet") {
+    return NativeSpreadsheetSession.create(runtime, input.replicaNamespace);
+  }
+  if (input.modality === "document") {
+    return NativeDocumentSession.create(runtime, input.replicaNamespace);
+  }
+  return NativePresentationSession.create(runtime, input.replicaNamespace);
+}
+function openNativeArtifactSession(runtime, input) {
+  if (input.modality === "spreadsheet")
+    return NativeSpreadsheetSession.open(runtime, input.snapshot);
+  if (input.modality === "document") return NativeDocumentSession.open(runtime, input.snapshot);
+  return NativePresentationSession.open(runtime, input.snapshot);
+}
+function assertSpreadsheetIntent(intentBytes) {
+  const intent = decodeEditableArtifactMutationIntent(intentBytes);
+  if (intent.envelopeVersion !== EDITABLE_ARTIFACT_INTENT_VERSION || intent.protocolVersion !== 1 || intent.modelSchemaVersion !== 1 || intent.commandProtocolVersion !== SPREADSHEET_ARTIFACT_COMMAND_VERSION) {
+    throw new ArtifactRuntimeError(
+      "ARTIFACT_RUNTIME_INCOMPATIBLE",
+      "Spreadsheet intent versions do not match the loaded production kernel"
+    );
+  }
+  assertCanonicalSpreadsheetArtifactCommandBytes(intent.commandBytes);
+  hashEditableArtifactMutationIntentBytes(intentBytes);
+}
+function requireNativeSpreadsheetRuntime(runtime) {
+  requireNativeRuntime(runtime);
+}
+function requireNativeRuntime(runtime) {
+  if (runtime.kind !== "native" || runtime.target === "wasm-web") {
+    throw new ArtifactRuntimeError(
+      "ARTIFACT_RUNTIME_UNAVAILABLE",
+      "NativeSpreadsheetSession requires an exact local N-API kernel; browser editing uses @opengeni/sdk/editable-artifacts"
+    );
+  }
+}
+
+export {
+  NativeSpreadsheetSession,
+  NativeDocumentSession,
+  NativePresentationSession,
+  NativeTextLayoutSession,
+  createNativeArtifactSession,
+  openNativeArtifactSession,
+  SPREADSHEET_ARTIFACT_COMMAND_VERSION2 as SPREADSHEET_ARTIFACT_COMMAND_VERSION,
+  assertCanonicalSpreadsheetArtifactCommandBytes2 as assertCanonicalSpreadsheetArtifactCommandBytes,
+  decodeSpreadsheetArtifactCommandBatch,
+  editableArtifactStableId,
+  encodeSpreadsheetArtifactCommandBatch2 as encodeSpreadsheetArtifactCommandBatch,
+  spreadsheetSheetId
+};
+//# sourceMappingURL=chunk-B2ZJRZDA.js.map