1 files changed, 91 insertions, 0 deletions
diff --git a/packages/meshbay-hub/src/meshbay_hub/static/file-utils.js b/packages/meshbay-hub/src/meshbay_hub/static/file-utils.js
index a005e2e..b44d105 100644
--- a/packages/meshbay-hub/src/meshbay_hub/static/file-utils.js
+++ b/packages/meshbay-hub/src/meshbay_hub/static/file-utils.js
@@ -1,5 +1,7 @@
 import * as downloads from './downloads.js';
 import * as platform from './platform.js';
+import { t } from './i18n.js';
+import { ZipStream, entriesUnder } from './zipstream.js';
 
 const FILE_ICONS = {
   video: '\u{1F3AC}', audio: '\u{1F3B5}', image: '\u{1F5BC}',
@@ -200,8 +202,97 @@ async function downloadEntry(transfers, transport, gek, entry) {
   });
 }
 
+/**
+ * Download a directory as a zip, written straight to disk.
+ *
+ * An archive of a group directory is routinely tens of gigabytes, so it is
+ * never held anywhere: each file is fetched chunk by chunk, decrypted, and
+ * handed to the zip writer, which hands it to the file the browser opened.
+ * Peak memory is one chunk plus one small record per file.
+ *
+ * Without the File System Access API there is nowhere to stream to, and the
+ * only alternative is to build the whole thing in memory — so that path is
+ * offered but says what it costs first.
+ *
+ * Lifted out of files-app.js (docs/photos.md §3) so photos-app.js's own
+ * "zip this album" button calls the same implementation rather than a
+ * second one — nothing here is Files-specific once `entries`/`transport`/
+ * `gek`/`setError` are passed in, the same shared-context shape every app
+ * already receives (apps.md §2).
+ */
+async function downloadDirectory(transfers, transport, gek, entries, dir, { setError }) {
+  if (!transport || !transport.connected) return;
+
+  const files = entriesUnder(entries, dir);
+  if (!files.length) {
+    setError(t('group.zip_empty'));
+    return;
+  }
+  const totalBytes = files.reduce((n, f) => n + (f.entry.size || 0), 0);
+  const suggested = (dir.split('/').pop() || 'files') + '.zip';
+
+  // totalBytes decides how this is delivered, but it is not the archive's
+  // size — headers and the central directory come on top — so it is not
+  // announced as a Content-Length that the download would then miss.
+  const target = await _openDownloadTarget(suggested, totalBytes, {
+    types: [{ description: 'ZIP archive',
+              accept: { 'application/zip': ['.zip'] } }],
+  }, 0);
+  if (target === false) return;
+  if (!target && !confirm(t('group.zip_no_stream', {
+    size: formatSize(totalBytes), name: suggested,
+  }))) {
+    return;
+  }
+  const zipOpenRef = { url: null };
+
+  transfers.start({
+    kind: 'download', name: (target && target.name) || suggested,
+    total: totalBytes, transport,
+    open: target
+      ? (target.open || null)
+      : () => { if (zipOpenRef.url) window.open(zipOpenRef.url, '_blank'); },
+    run: async ({ signal, onProgress }) => {
+      const writable = target ? target.writable : null;
+      const parts = writable ? null : [];
+      let written = 0;
+      try {
+        const zip = new ZipStream(async (bytes) => {
+          if (writable) await writable.write(bytes);
+          else parts.push(bytes.slice());
+        });
+
+        for (const { entry, name } of files) {
+          await zip.begin(name, entry.size,
+                          new Date((entry.added_at || 0) * 1000));
+          // A zero-byte file has no chunk to ask for; the header and an empty
+          // descriptor are the whole entry.
+          const totalChunks = Math.ceil(entry.size / CHUNK_SIZE);
+          if (totalChunks > 0) await pipelinedDownload(
+            transport, gek, entry.id, totalChunks,
+            (bytes) => { written += bytes; onProgress(written, totalBytes); },
+            // pipelinedDownload writes in order, which the archive needs.
+            { write: (plaintext) => zip.write(plaintext) }, signal);
+          await zip.end();
+        }
+        await zip.finish();
+        if (writable) await writable.close();
+        else {
+          const blob = new Blob(parts, { type: 'application/zip' });
+          _saveBlob(blob, suggested);
+          zipOpenRef.url = URL.createObjectURL(blob);
+        }
+      } catch (err) {
+        if (writable) await writable.abort().catch(() => {});
+        throw err;
+      }
+    },
+  });
+}
+
 export {
   FILE_ICONS,
   formatSize, formatDate, PREVIEWABLE_TEXT, canPreview, CHUNK_SIZE,
   _openDownloadTarget, _saveBlob, _b64ToU8, pipelinedDownload, downloadEntry,
+  downloadDirectory,
 };