relic-mcp 0.14.4 → 0.15.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
     {
       "name": "relic",
       "description": "Publish a file from your machine as an encrypted, shareable link. The agent encrypts locally, uploads only ciphertext, and hands back a URL whose fragment holds the key, so the service stores something it cannot read.",
-      "version": "0.14.4",
+      "version": "0.15.0",
       "source": "./",
       "author": {
         "name": "The Bushido Collective",
@@ -21,6 +21,6 @@
     }
   ],
   "metadata": {
-    "version": "0.14.4"
+    "version": "0.15.0"
   }
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "relic",
-  "version": "0.14.4",
+  "version": "0.15.0",
   "description": "Publish a file from your machine as an encrypted, shareable link. The agent encrypts locally, uploads only ciphertext, and hands back a URL whose fragment holds the key, so the service stores something it cannot read.",
   "mcpServers": "./mcp-servers.json",
   "author": {

package/dist/cover/cover.js

@@ -1202,6 +1202,68 @@ var require_build = __commonJS(function(exports) {
   exports.default = LinesAndColumns;
 });
 
+// ../relic-viewer/src/content.ts
+var CONTENT_BATCH_BYTES = 8 * 1024 * 1024;
+var CONTENT_HEAD_BYTES = 65536;
+var CONTENT_TAIL_BYTES = 65557;
+var MAX_CONTENT_READ_BYTES = 16 * 1024 * 1024;
+var DOCUMENT_RENDER_LIMIT_BYTES = 100 * 1024 * 1024;
+
+class ContentStoreError extends Error {
+  constructor(cause) {
+    super("The browser could not hold the decrypted content.", { cause });
+    this.name = "ContentStoreError";
+  }
+}
+function sliceBlob(blob, start, end, type) {
+  try {
+    return blob.slice(start, end, type);
+  } catch (cause) {
+    throw new ContentStoreError(cause);
+  }
+}
+async function readBlob(blob) {
+  try {
+    const bytes = new Uint8Array(await blob.arrayBuffer());
+    if (bytes.length !== blob.size)
+      throw new Error("short Blob read");
+    return bytes;
+  } catch (cause) {
+    throw new ContentStoreError(cause);
+  }
+}
+function contentFromParts(base, head, tail) {
+  return {
+    size: base.size,
+    head,
+    tail,
+    blob(type) {
+      return sliceBlob(base, 0, base.size, type);
+    },
+    async read(start, end) {
+      if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start || end > base.size || end - start > MAX_CONTENT_READ_BYTES) {
+        throw new RangeError("Invalid or oversized content read");
+      }
+      return readBlob(sliceBlob(base, start, end));
+    },
+    async readWhole(limit) {
+      if (!Number.isSafeInteger(limit) || limit < 0 || limit > DOCUMENT_RENDER_LIMIT_BYTES) {
+        throw new RangeError("Invalid whole-content read limit");
+      }
+      if (base.size > limit)
+        return;
+      return readBlob(base);
+    }
+  };
+}
+async function contentFromBlob(blob) {
+  const [head, tail] = await Promise.all([
+    readBlob(sliceBlob(blob, 0, Math.min(blob.size, CONTENT_HEAD_BYTES))),
+    readBlob(sliceBlob(blob, Math.max(0, blob.size - CONTENT_TAIL_BYTES), blob.size))
+  ]);
+  return contentFromParts(blob, head, tail);
+}
+
 // ../relic-viewer/src/markdown.ts
 function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
@@ -44726,6 +44788,81 @@ globalThis.pdfjsLib = {
   XfaLayer
 };
 
+// ../relic-viewer/src/pdf.ts
+var PDF_INITIAL_BYTES = 1024 * 1024;
+var PDF_RANGE_CHUNK_SIZE = 65536;
+
+class RelicPdfRangeTransport extends PDFDataRangeTransport {
+  content;
+  onError;
+  aborted = false;
+  failed = false;
+  constructor(content, initialData, onError) {
+    super(content.size, initialData);
+    this.content = content;
+    this.onError = onError;
+  }
+  requestDataRange(begin, end) {
+    if (this.aborted || this.failed)
+      return;
+    this.readRange(begin, end).then((bytes) => {
+      if (!this.aborted && !this.failed)
+        this.onDataRange(begin, bytes);
+    }).catch((error) => {
+      if (this.aborted || this.failed)
+        return;
+      this.failed = true;
+      this.onError(error);
+    });
+  }
+  abort() {
+    this.aborted = true;
+  }
+  async readRange(begin, end) {
+    if (!Number.isSafeInteger(begin) || !Number.isSafeInteger(end) || begin < 0 || end < begin || end > this.content.size) {
+      throw new RangeError("Invalid PDF range");
+    }
+    const length = end - begin;
+    if (length <= MAX_CONTENT_READ_BYTES) {
+      const bytes = await this.content.read(begin, end);
+      if (bytes.byteLength !== length)
+        throw new Error("Short PDF range read");
+      return bytes;
+    }
+    const bytes = new Uint8Array(length);
+    for (let start = begin;start < end; start += MAX_CONTENT_READ_BYTES) {
+      if (this.aborted)
+        return new Uint8Array(0);
+      const stop = Math.min(start + MAX_CONTENT_READ_BYTES, end);
+      const chunk = await this.content.read(start, stop);
+      if (chunk.byteLength !== stop - start)
+        throw new Error("Short PDF range read");
+      bytes.set(chunk, start - begin);
+    }
+    return bytes;
+  }
+}
+async function createPdfLoadingTask(content, signal) {
+  const initialData = await content.read(0, Math.min(content.size, PDF_INITIAL_BYTES));
+  if (signal?.aborted)
+    throw new Error("PDF loading cancelled");
+  if (initialData.byteLength !== Math.min(content.size, PDF_INITIAL_BYTES))
+    throw new Error("Short PDF initial read");
+  const { promise: failure, reject: rejectFailure } = Promise.withResolvers();
+  failure.catch(() => {
+    return;
+  });
+  const range = new RelicPdfRangeTransport(content, initialData, rejectFailure);
+  const task = getDocument({
+    range,
+    length: content.size,
+    rangeChunkSize: PDF_RANGE_CHUNK_SIZE,
+    disableAutoFetch: true,
+    disableStream: true
+  });
+  return { task, failure };
+}
+
 // ../relic-viewer/src/cover/pdf-trim.ts
 var PDF_GUTTER_PX = 20;
 var PDF_CANVAS_WIDTH = 600;
@@ -44778,21 +44915,21 @@ function trimPdfPage(ink, pageWidth) {
 // ../relic-viewer/src/cover/pdf.ts
 var PDF_CANVAS_HEIGHT = 315;
 var PDF_DEVICE_SCALE = 2;
-var workerInitialized = false;
 function ensurePdfWorker() {
-  if (!workerInitialized) {
-    GlobalWorkerOptions.workerPort = new Worker("/pdf.worker.mjs", {
-      type: "module"
-    });
-    workerInitialized = true;
-  }
+  GlobalWorkerOptions.workerSrc = "/pdf.worker.mjs";
 }
-async function renderPdfCover(bytes, root) {
+async function renderPdfCover(content, root) {
   ensurePdfWorker();
-  let pdfDoc;
   try {
-    const loadingTask = getDocument({ data: bytes });
-    pdfDoc = await loadingTask.promise;
+    const { task, failure } = await createPdfLoadingTask(content);
+    try {
+      const pdfDoc = await Promise.race([task.promise, failure]);
+      return await renderPdfCoverDocument(pdfDoc, root, failure);
+    } finally {
+      await task.destroy().catch(() => {
+        return;
+      });
+    }
   } catch (err) {
     return {
       ok: false,
@@ -44800,9 +44937,11 @@ async function renderPdfCover(bytes, root) {
       detail: err instanceof Error ? err.message : String(err)
     };
   }
+}
+async function renderPdfCoverDocument(pdfDoc, root, failure) {
   let page;
   try {
-    page = await pdfDoc.getPage(1);
+    page = await Promise.race([pdfDoc.getPage(1), failure]);
   } catch (err) {
     return {
       ok: false,
@@ -44827,11 +44966,14 @@ async function renderPdfCover(bytes, root) {
     };
   }
   try {
-    await page.render({
-      canvasContext: measureCtx,
-      viewport: refViewport,
-      canvas: measureCanvas
-    }).promise;
+    await Promise.race([
+      page.render({
+        canvasContext: measureCtx,
+        viewport: refViewport,
+        canvas: measureCanvas
+      }).promise,
+      failure
+    ]);
   } catch (err) {
     return {
       ok: false,
@@ -44864,11 +45006,14 @@ async function renderPdfCover(bytes, root) {
     };
   }
   try {
-    await page.render({
-      canvasContext: renderCtx,
-      viewport: finalViewport,
-      canvas: renderCanvas
-    }).promise;
+    await Promise.race([
+      page.render({
+        canvasContext: renderCtx,
+        viewport: finalViewport,
+        canvas: renderCanvas
+      }).promise,
+      failure
+    ]);
   } catch (err) {
     return {
       ok: false,
@@ -44896,7 +45041,7 @@ async function fetchInputBlob(input) {
     if (!res.ok) {
       throw new Error(`Failed to fetch input part ${i}: ${res.status}`);
     }
-    parts.push(await res.arrayBuffer());
+    parts.push(await res.blob());
   }
   return new Blob(parts, { type: input.mimetype });
 }
@@ -45084,8 +45229,7 @@ async function renderKind(request, root) {
       }
     }
     case "pdf": {
-      const arrayBuffer = await blob.arrayBuffer();
-      return renderPdfCover(new Uint8Array(arrayBuffer), root);
+      return renderPdfCover(await contentFromBlob(blob), root);
     }
   }
 }

package/dist/cover/frame.html

@@ -11390,15 +11390,91 @@ var MAX_HEADER_BYTES = 2 + (2 + MAX_FILENAME_BYTES + 2 + MAX_MIMETYPE_BYTES + 8
 var encoder = new TextEncoder;
 var decoder = new TextDecoder("utf-8", { fatal: false });
 
+// ../relic-format/src/limits.ts
+var PLAINTEXT_CAP_BYTES = 500 * 1024 * 1024;
+
 // ../relic-format/src/rfc8188.ts
 var TAG_BYTES = 16;
 var DELIMITER_BYTES = 1;
 var RECORD_OVERHEAD = TAG_BYTES + DELIMITER_BYTES;
 var CEK_INFO = new TextEncoder().encode("Content-Encoding: aes128gcm\x00");
 var NONCE_INFO = new TextEncoder().encode("Content-Encoding: nonce\x00");
-
-// ../relic-format/src/container.ts
-var PLAINTEXT_CAP_BYTES = 100 * 1024 * 1024;
+// ../relic-format/src/crc32c.ts
+var CRC32C_TABLE = new Uint32Array(256);
+for (let index = 0;index < 256; index++) {
+  let value = index;
+  for (let bit = 0;bit < 8; bit++) {
+    value = value & 1 ? value >>> 1 ^ 2197175160 : value >>> 1;
+  }
+  CRC32C_TABLE[index] = value >>> 0;
+}
+// ../relic-format/src/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
 // ../relic-format/src/id.ts
 var RESERVED_SEGMENTS = [
   "abuse",
@@ -11431,7 +11507,10 @@ function foldAliases(lowered) {
   return out;
 }
 // ../relic-format/src/otio-zip.ts
-var MAX_EXPANDED_ZIP_BYTES = 100 * 1024 * 1024;
+var MAX_INFLATED_ZIP_BYTES = 100 * 1024 * 1024;
+var OTIO_DOCUMENT_MAX_BYTES = 100 * 1024 * 1024;
+var MAX_ZIP_DIRECTORY_BYTES = 16 * 1024 * 1024;
+var ZIP_READ_CHUNK_BYTES = 8 * 1024 * 1024;
 var MAX_OTIO_BUNDLE_MEDIA_ENTRIES = 65535 - 3;
 var CRC_TABLE = new Uint32Array(256);
 for (let i = 0;i < 256; i++) {

package/dist/cover/pdf.worker.mjs

@@ -20,6 +20,11 @@
  * JavaScript code in this page
  */
 
+/**
+ * Modified by The Bushido Collective: stop indirect-object lookahead at endobj
+ * to avoid scanning the following whitespace in range-loaded PDFs.
+ */
+
 /**
  * pdfjsVersion = 5.4.149
  * pdfjsBuild = 9e2e9e209
@@ -11481,6 +11486,71 @@ class Lexer {
     }
   }
 }
+class IndirectObjectLexer extends Lexer {
+  // Stop before lookahead reads beyond an indirect object's top-level endobj.
+  // Dictionary entries alternate between names and values; a closer in value
+  // position is a value, and a mismatched closer never closes a container.
+  #openers = [];
+  #ended = false;
+  #tracking = true;
+  getObj() {
+    if (this.#ended) {
+      return EOF;
+    }
+    const obj = super.getObj();
+    if (!this.#tracking) {
+      return obj;
+    }
+    // Inline images have their own parser and delimiter rules.
+    if (obj instanceof Cmd && obj.cmd === "BI") {
+      this.#openers.length = 0;
+      this.#tracking = false;
+      return obj;
+    }
+    const top = this.#openers.at(-1);
+    if (top === "<<") {
+      if (obj instanceof Name) {
+        this.#openers[this.#openers.length - 1] = "<<value";
+      }
+      if (!(obj instanceof Cmd) || obj.cmd !== ">>") {
+        return obj;
+      }
+    } else if (top === "<<value") {
+      this.#openers[this.#openers.length - 1] = "<<";
+      if (obj instanceof Cmd && (obj.cmd === ">>" || obj.cmd === "]")) {
+        return obj;
+      }
+    }
+    if (obj instanceof Cmd) {
+      switch (obj.cmd) {
+        case "<<":
+        case "[":
+          // Fall back to the original lexer on excessive nesting.
+          if (this.#openers.length === 1024) {
+            this.#openers.length = 0;
+            this.#tracking = false;
+          } else {
+            this.#openers.push(obj.cmd);
+          }
+          break;
+        case ">>":
+          if (top === "<<") {
+            this.#openers.pop();
+          }
+          break;
+        case "]":
+          if (top === "[") {
+            this.#openers.pop();
+          }
+          break;
+        case "endobj":
+          this.#ended = this.#openers.length === 0;
+          break;
+      }
+    }
+    return obj;
+  }
+}
 class Linearization {
   static create(stream) {
     function getInt(linDict, name, allowZeroValue = false) {
@@ -11505,7 +11575,7 @@ class Linearization {
       throw new Error("Hint array in the linearization dictionary is invalid.");
     }
     const parser = new Parser({
-      lexer: new Lexer(stream),
+      lexer: new IndirectObjectLexer(stream),
       xref: null
     });
     const obj1 = parser.getObj();
@@ -54884,7 +54954,7 @@ class XRef {
         startXRefParsedCache.add(startXRef);
         stream.pos = startXRef + stream.start;
         const parser = new Parser({
-          lexer: new Lexer(stream),
+          lexer: new IndirectObjectLexer(stream),
           xref: this,
           allowStreams: true
         });
@@ -55002,7 +55072,7 @@ class XRef {
     }
     const stream = this.stream.makeSubStream(xrefEntry.offset + this.stream.start);
     const parser = new Parser({
-      lexer: new Lexer(stream),
+      lexer: new IndirectObjectLexer(stream),
       xref: this,
       allowStreams: true
     });

package/dist/cover/styles.css

@@ -760,7 +760,7 @@ body {
      width while the actions lost their labels, which pushed Report off the
      row at 420px. Its accessible name carries the meaning when the text
      goes. */
-  .action span:not(.action-count, .decision-tally, .decision-tally > span):not(:is(.share-panel, .decision-panel, .copy-panel, .band-more-list, .card-actions) span) {
+  .action span:not(.action-count, .decision-tally, .decision-tally > span):not(:is(.share-panel, .decision-panel, .copy-panel, .band-more-list, .card-actions, .large-open) span) {
     position: absolute;
     width: 1px;
     height: 1px;
@@ -6252,3 +6252,153 @@ mark[data-concealed] {
   border-bottom-color: transparent !important;
   box-shadow: none !important;
 }
+
+/* The existing source table, kept to one viewport rather than a giant canvas. */
+.stage:has(.text-window) {
+  height: 100%;
+  min-height: 20rem;
+  display: flex;
+  flex-direction: column;
+}
+
+.text-window.doc {
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+  min-height: 0;
+  min-width: 0;
+  max-width: none;
+  width: 100%;
+  margin: 0;
+  padding: 0;
+}
+
+.text-window-tools {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+  padding: 0.5rem 0.75rem;
+  border-bottom: 1px solid var(--rule);
+  background: var(--surface);
+  font-family: var(--mono);
+  font-size: 0.75rem;
+}
+
+.text-window-tools label {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+
+.text-window-tools input {
+  width: 7rem;
+  max-width: 35vw;
+  padding: 0.25rem;
+  background: var(--ground);
+  color: var(--ink);
+  border: 1px solid var(--rule-strong);
+  font: inherit;
+}
+
+.text-window-tools output {
+  min-width: 0;
+  overflow-wrap: anywhere;
+  color: var(--ink-soft);
+}
+
+.text-window-body {
+  display: flex;
+  flex: 1;
+  min-height: 0;
+  min-width: 0;
+}
+
+/* One column as wide as the widest row, so every row, and the line number
+   stuck to its left edge, spans the whole horizontal scroll. */
+.text-window-page {
+  display: grid;
+  grid-template-columns: minmax(max-content, 1fr);
+  align-content: start;
+  flex: 1;
+  min-width: 0;
+  margin: 0;
+  padding: 0 0.75rem 0 0;
+  overflow-x: auto;
+  overflow-y: hidden;
+  font: 12px/20px var(--mono);
+  tab-size: 4;
+  white-space: pre;
+  background: var(--surface);
+  /* A revealed quote scrolls clear of the sticky line numbers: 8ch number,
+     2ch padding, 1ch margin and the 1px rule. */
+  scroll-padding-inline: calc(11ch + 1px) 0.75rem;
+}
+
+.text-window-row {
+  display: block;
+  min-height: 20px;
+}
+
+.text-window-row::before {
+  content: attr(data-line);
+  display: inline-block;
+  position: sticky;
+  left: 0;
+  width: 8ch;
+  padding: 0 1ch;
+  margin-right: 1ch;
+  text-align: right;
+  color: var(--ink-soft);
+  background: var(--surface);
+  border-right: 1px solid var(--rule);
+  user-select: none;
+}
+
+.text-window-scroll {
+  writing-mode: vertical-lr;
+  direction: ltr;
+  width: 1.5rem;
+  min-height: 0;
+  margin: 0;
+  accent-color: var(--patina);
+}
+
+.text-window-page:focus-visible,
+.text-window-scroll:focus-visible,
+.text-window-tools input:focus-visible {
+  outline: 2px solid var(--patina);
+  outline-offset: -2px;
+}
+
+.large-open {
+  width: min(32rem, calc(100vw - 2rem));
+  max-height: calc(100dvh - 2rem);
+  padding: 1.5rem;
+  border: 1px solid var(--rule-strong);
+  background: var(--surface);
+  color: var(--ink);
+}
+
+.large-open::backdrop {
+  background: rgb(0 0 0 / 45%);
+}
+
+.large-open h1 {
+  margin: 0;
+  font: 1.4rem/1.3 var(--serif);
+  overflow-wrap: anywhere;
+}
+
+.large-open p {
+  color: var(--ink-soft);
+  font: 0.8rem/1.5 var(--mono);
+  overflow-wrap: anywhere;
+}
+
+.large-open-actions {
+  display: flex;
+  justify-content: flex-end;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+}