@cosmicdrift/kumiko-framework 0.328.0 → 0.329.0

package/src/files/__tests__/write-stream.test.ts

@@ -1,250 +0,0 @@
-// Storage-Provider writeStream-API (S2.U3 Atom 1d).
-//
-// Pinst:
-//   - In-memory-Provider: writeStream collected chunks + macht
-//     read-Roundtrip identisch zu write(uint8array).
-//   - Local-Provider: writeStream schreibt atomar via tmp + rename,
-//     halb-fertige Stream-Bricht hinterlassen keine Garbage am Final-
-//     Pfad.
-//   - Beide Provider liefern die Bytes via read() identisch zurueck —
-//     kein chunk-Loss, kein chunk-Order-Verlust.
-//
-// AsyncIterable-source pinst die Streaming-Semantik (Caller streamt
-// chunk-fuer-chunk, Provider niemals alles im Memory).
-
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtemp, readdir, rm, stat } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { waitFor } from "../../testing";
-import { createInMemoryFileProvider } from "../in-memory-provider";
-import { createLocalProvider } from "../local-provider";
-
-async function* fromChunks(chunks: Uint8Array[]): AsyncIterable<Uint8Array> {
-  for (const c of chunks) {
-    yield c;
-  }
-}
-
-async function* slowChunks(chunks: Uint8Array[], delayMs: number): AsyncIterable<Uint8Array> {
-  for (const c of chunks) {
-    await new Promise((r) => setTimeout(r, delayMs));
-    yield c;
-  }
-}
-
-describe("FileStorageProvider.writeStream — in-memory", () => {
-  test("schreibt 3 chunks + read liefert konkateniert zurueck", async () => {
-    const provider = createInMemoryFileProvider();
-    const chunks = [
-      new Uint8Array([1, 2, 3]),
-      new Uint8Array([4, 5, 6]),
-      new Uint8Array([7, 8, 9]),
-    ];
-    await provider.writeStream("test/file.bin", fromChunks(chunks));
-
-    const data = await provider.read("test/file.bin");
-    expect(Array.from(data)).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);
-  });
-
-  test("leerer Stream → leere Datei", async () => {
-    const provider = createInMemoryFileProvider();
-    await provider.writeStream("empty.bin", fromChunks([]));
-
-    const data = await provider.read("empty.bin");
-    expect(data.byteLength).toBe(0);
-  });
-
-  test("mimeType-Option wird in der gespeicherten Entry erhalten", async () => {
-    // Kein direkter Read-Pfad fuer mimeType — wir checken via existing-
-    // Marker (write-Pfad teilt den storage-shape). Symmetrie-Test:
-    // ein write() + ein writeStream() mit gleichem key + gleichem
-    // mimeType muessen byte-identische Reads liefern.
-    const a = createInMemoryFileProvider();
-    const b = createInMemoryFileProvider();
-    const bytes = new Uint8Array([42, 43, 44]);
-
-    await a.write("k", bytes, "application/zip");
-    if (!b.writeStream) throw new Error("writeStream missing");
-    await b.writeStream("k", fromChunks([bytes]), { mimeType: "application/zip" });
-
-    expect(Array.from(await a.read("k"))).toEqual(Array.from(await b.read("k")));
-  });
-});
-
-describe("FileStorageProvider.writeStream — local-filesystem", () => {
-  let basePath: string;
-
-  beforeEach(async () => {
-    basePath = await mkdtemp(join(tmpdir(), "kumiko-write-stream-"));
-  });
-
-  afterEach(async () => {
-    await rm(basePath, { recursive: true, force: true });
-  });
-
-  test("schreibt + read roundtrip mit chunked source", async () => {
-    const provider = createLocalProvider(basePath);
-    const chunks = [new Uint8Array([10, 20, 30]), new Uint8Array([40, 50, 60])];
-    await provider.writeStream("dir/foo.bin", fromChunks(chunks));
-
-    const data = await provider.read("dir/foo.bin");
-    expect(Array.from(data)).toEqual([10, 20, 30, 40, 50, 60]);
-  });
-
-  test("legt parent-Verzeichnisse rekursiv an", async () => {
-    const provider = createLocalProvider(basePath);
-    await provider.writeStream("deeply/nested/path/file.bin", fromChunks([new Uint8Array([1])]));
-
-    const stats = await stat(join(basePath, "deeply/nested/path/file.bin"));
-    expect(stats.isFile()).toBe(true);
-  });
-
-  test("atomar: bei wirfendem Stream entsteht KEIN final-Pfad-File", async () => {
-    const provider = createLocalProvider(basePath);
-
-    async function* failingSource(): AsyncIterable<Uint8Array> {
-      yield new Uint8Array([1, 2, 3]);
-      throw new Error("synthetic mid-stream failure");
-    }
-
-    await expect(provider.writeStream("dir/half.bin", failingSource())).rejects.toThrow(
-      /synthetic mid-stream failure/,
-    );
-
-    expect(await provider.exists("dir/half.bin")).toBe(false);
-  });
-
-  test("atomar: nach Failure ist KEIN final-Pfad-File da (.tmp-Leak ist best-effort)", async () => {
-    // Echte Atomicity-Garantie: der final-Pfad ist niemals halb-fertig
-    // sichtbar. tmp-Files koennen je nach OS-Race im destroy-Pfad
-    // kurz liegen bleiben — kein Korrektheitsproblem (kein Reader
-    // sucht nach `*.tmp`-Patterns), nur Operations-Hygiene.
-    const provider = createLocalProvider(basePath);
-
-    async function* failing(): AsyncIterable<Uint8Array> {
-      yield new Uint8Array([99]);
-      throw new Error("fail");
-    }
-
-    await expect(provider.writeStream("subdir/leak-check.bin", failing())).rejects.toThrow();
-
-    // Final-Pfad ist NICHT da — das ist die harte Garantie.
-    expect(await provider.exists("subdir/leak-check.bin")).toBe(false);
-
-    // tmp-Files duerfen nicht den final-Namen haben (sonst kein Atomicity).
-    const entries = await readdir(join(basePath, "subdir"));
-    for (const entry of entries) {
-      expect(entry).not.toBe("leak-check.bin");
-    }
-  });
-
-  test("ueberschreibt existing file atomar (rename ueber bestehenden Pfad)", async () => {
-    const provider = createLocalProvider(basePath);
-
-    await provider.write("k", new Uint8Array([1, 1, 1]));
-    await provider.writeStream("k", fromChunks([new Uint8Array([2, 2, 2])]));
-
-    const data = await provider.read("k");
-    expect(Array.from(data)).toEqual([2, 2, 2]);
-  });
-
-  test("write/read/delete reject a key that escapes basePath; exists reports false", async () => {
-    const provider = createLocalProvider(basePath);
-    const escapingKey = "../../etc/passwd";
-
-    await expect(provider.write(escapingKey, new Uint8Array([1]))).rejects.toThrow(
-      /path-traversal/,
-    );
-    await expect(provider.read(escapingKey)).rejects.toThrow(/path-traversal/);
-    await expect(provider.delete(escapingKey)).rejects.toThrow(/path-traversal/);
-    // exists() treats any stat failure (missing file, escaping key) as "not there".
-    expect(await provider.exists(escapingKey)).toBe(false);
-  });
-});
-
-describe("FileStorageProvider.writeStream — Streaming-Property", () => {
-  // Pinst dass writeStream tatsaechlich AsyncIterable konsumiert ohne
-  // alle chunks in eine Promise.resolve(...) Array zu converten.
-  // Wenn ein Provider intern das chunks-Array sammelt, ist das fuer
-  // unsere semantischen Garantien OK — wir testen nur das Resultat.
-  // Dieser Test sichert dass der Caller ein REIN async-iterable
-  // uebergeben kann (z.B. ZIP-Stream der chunks lazy generiert).
-
-  test("Source mit Promise-delays wird korrekt verarbeitet", async () => {
-    const provider = createInMemoryFileProvider();
-
-    async function* lazySource(): AsyncIterable<Uint8Array> {
-      await new Promise((r) => setTimeout(r, 5));
-      yield new Uint8Array([1]);
-      await new Promise((r) => setTimeout(r, 5));
-      yield new Uint8Array([2]);
-      await new Promise((r) => setTimeout(r, 5));
-      yield new Uint8Array([3]);
-    }
-
-    await provider.writeStream("lazy.bin", lazySource());
-
-    const data = await provider.read("lazy.bin");
-    expect(Array.from(data)).toEqual([1, 2, 3]);
-  });
-
-  test("local-Provider streamt WAEHREND der Source yieldet (tmp-File existiert pre-completion)", async () => {
-    // Echter Streaming-Property-Test: bei langsamen Source-yields muss
-    // der local-Provider die tmp-File anfangen zu schreiben WAEHREND
-    // wir noch chunks zur Verfuegung stellen — nicht erst alle chunks
-    // collecten.
-    //
-    // Pattern: 5 chunks mit je 30ms delay zwischen yields. Wir starten
-    // writeStream + pollen alle 10ms (max 200ms) bis tmp-File auftaucht.
-    // Bei collect-then-write taucht NIE eine tmp-File auf — Test failed
-    // dann via Timeout. Poll-basiert statt time-hardcoded gibt CI-
-    // Geschwindigkeits-Toleranz; flake-frei solange total-source-time
-    // (5 × 30ms = 150ms) > poll-Granularitaet (10ms).
-    const basePath = await mkdtemp(join(tmpdir(), "kumiko-stream-prop-"));
-    try {
-      const provider = createLocalProvider(basePath);
-      const chunks = [
-        new Uint8Array([1]),
-        new Uint8Array([2]),
-        new Uint8Array([3]),
-        new Uint8Array([4]),
-        new Uint8Array([5]),
-      ];
-      const writePromise = provider.writeStream("streamed.bin", slowChunks(chunks, 30));
-
-      // Poll bis tmp existiert ODER final schon fertig (zu schneller CI).
-      let hasTmp = false;
-      let alreadyDone = false;
-      await waitFor(
-        async () => {
-          const dirContents = await readdir(basePath);
-          hasTmp = dirContents.some((f) => f.endsWith(".tmp"));
-          alreadyDone = dirContents.includes("streamed.bin");
-          return hasTmp || alreadyDone;
-        },
-        { delays: Array(20).fill(10) },
-      );
-      if (alreadyDone && !hasTmp) {
-        throw new Error(
-          "slowChunks-delay zu kurz fuer CI: writeStream war fertig bevor poll start. " +
-            "delayMs erhoehen oder chunks reduzieren.",
-        );
-      }
-      expect(hasTmp).toBe(true); // tmp existiert WAEHREND yields
-
-      // Warten auf completion
-      await writePromise;
-
-      // Nach completion: tmp ist weg, final-File ist da
-      const finalContents = await readdir(basePath);
-      expect(finalContents).toContain("streamed.bin");
-      expect(finalContents.filter((f) => f.endsWith(".tmp"))).toEqual([]);
-
-      const data = await provider.read("streamed.bin");
-      expect(Array.from(data)).toEqual([1, 2, 3, 4, 5]);
-    } finally {
-      await rm(basePath, { recursive: true, force: true });
-    }
-  });
-});

package/src/files/__tests__/zip-stream.test.ts

@@ -1,357 +0,0 @@
-// Streaming-ZIP-Builder Tests (S2.U3 Atom 3a).
-//
-// Drei-Schichten-Test:
-//   1. Strukturelle Asserts: ZIP-Magic-Numbers an den richtigen Stellen,
-//      EOCD am Ende, central-dir-Count matcht emittierte Entries.
-//   2. CRC32-Korrektheit gegen Reference-Implementation (crypto.subtle
-//      oder bekannte Test-Vektoren).
-//   3. Real-Roundtrip via `unzip` shell-binary: ZIP in tmp-File schreiben,
-//      `unzip -l` + `unzip -p` aufrufen, Inhalt verifizieren. Pinst
-//      dass das ZIP von einem realen Decoder (Info-ZIP) gelesen werden
-//      kann — kein "passt nur in unserer eigenen reverse-engineerten
-//      Welt".
-
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { spawn } from "node:child_process";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { getTemporal } from "../../time";
-import { createZipStream, type ZipEntry } from "../zip-stream";
-
-async function* fromString(s: string): AsyncIterable<Uint8Array> {
-  yield new TextEncoder().encode(s);
-}
-
-async function* fromBytes(b: Uint8Array): AsyncIterable<Uint8Array> {
-  yield b;
-}
-
-async function* fromEntries(entries: ZipEntry[]): AsyncIterable<ZipEntry> {
-  for (const e of entries) yield e;
-}
-
-async function collect(stream: AsyncIterable<Uint8Array>): Promise<Uint8Array> {
-  const chunks: Uint8Array[] = [];
-  let total = 0;
-  for await (const chunk of stream) {
-    chunks.push(chunk);
-    total += chunk.byteLength;
-  }
-  const out = new Uint8Array(total);
-  let off = 0;
-  for (const c of chunks) {
-    out.set(c, off);
-    off += c.byteLength;
-  }
-  return out;
-}
-
-function readU32LE(buf: Uint8Array, offset: number): number {
-  return new DataView(buf.buffer, buf.byteOffset + offset, 4).getUint32(0, true);
-}
-
-function readU16LE(buf: Uint8Array, offset: number): number {
-  return new DataView(buf.buffer, buf.byteOffset + offset, 2).getUint16(0, true);
-}
-
-describe("createZipStream :: structural asserts", () => {
-  test("leerer Stream → nur EOCD-Record (22 Bytes)", async () => {
-    const zip = await collect(createZipStream(fromEntries([])));
-    expect(zip.byteLength).toBe(22);
-    // EOCD-Magic 0x06054b50 ("PK\x05\x06")
-    expect(readU32LE(zip, 0)).toBe(0x06054b50);
-    // 0 entries
-    expect(readU16LE(zip, 8)).toBe(0);
-    expect(readU16LE(zip, 10)).toBe(0);
-  });
-
-  test("1 Entry → Local-File-Header + body + central-dir + EOCD", async () => {
-    const body = "hello";
-    const zip = await collect(
-      createZipStream(fromEntries([{ path: "greet.txt", data: fromString(body) }])),
-    );
-
-    // Local file header signature 0x04034b50 ("PK\x03\x04") am Anfang
-    expect(readU32LE(zip, 0)).toBe(0x04034b50);
-    // method = STORE = 0
-    expect(readU16LE(zip, 8)).toBe(0);
-    // filename length = 9 ("greet.txt")
-    expect(readU16LE(zip, 26)).toBe(9);
-    // body folgt nach 30+9=39 bytes
-    const bodyStart = 39;
-    const bodyBytes = zip.slice(bodyStart, bodyStart + 5);
-    expect(new TextDecoder().decode(bodyBytes)).toBe(body);
-
-    // EOCD am Ende
-    const eocdStart = zip.byteLength - 22;
-    expect(readU32LE(zip, eocdStart)).toBe(0x06054b50);
-    expect(readU16LE(zip, eocdStart + 8)).toBe(1); // 1 entry
-  });
-
-  test("3 Entries → 3 LFH + 3 central-dir-records + 1 EOCD", async () => {
-    const zip = await collect(
-      createZipStream(
-        fromEntries([
-          { path: "a.txt", data: fromString("aaa") },
-          { path: "b.txt", data: fromString("bbb") },
-          { path: "c.txt", data: fromString("ccc") },
-        ]),
-      ),
-    );
-
-    // EOCD reports 3 entries
-    const eocdStart = zip.byteLength - 22;
-    expect(readU32LE(zip, eocdStart)).toBe(0x06054b50);
-    expect(readU16LE(zip, eocdStart + 8)).toBe(3);
-    expect(readU16LE(zip, eocdStart + 10)).toBe(3);
-  });
-});
-
-describe("createZipStream :: CRC32 correctness", () => {
-  test("CRC32 von 'hello' matcht IEEE-802.3-Reference (0x3610a686)", async () => {
-    const zip = await collect(
-      createZipStream(fromEntries([{ path: "x.txt", data: fromString("hello") }])),
-    );
-    // CRC32 ist im LFH bei Offset 14
-    const crc = readU32LE(zip, 14);
-    // Reference: crc32("hello") = 0x3610a686 (verifiziert via
-    // python3 -c 'import zlib; print(hex(zlib.crc32(b"hello")))')
-    expect(crc).toBe(0x3610a686);
-  });
-
-  test("CRC32 von '123456789' matcht Industrie-Standard-Reference (0xCBF43926)", async () => {
-    // "123456789" → 0xCBF43926 ist DER IEEE-802.3 CRC32 Test-Vektor;
-    // RFC 1952 (gzip) und RFC 3309 nutzen ihn als Reference. Wenn unsere
-    // Implementation hier fehlt, ist die ganze CRC32-Algorithm broken.
-    const zip = await collect(
-      createZipStream(fromEntries([{ path: "x.txt", data: fromString("123456789") }])),
-    );
-    expect(readU32LE(zip, 14)).toBe(0xcbf43926);
-  });
-
-  test("CRC32 von leerem Body = 0", async () => {
-    const zip = await collect(
-      createZipStream(fromEntries([{ path: "empty.txt", data: fromBytes(new Uint8Array(0)) }])),
-    );
-    expect(readU32LE(zip, 14)).toBe(0);
-  });
-});
-
-describe("createZipStream :: UTF-8 filename support", () => {
-  test("General-Purpose-Flag Bit 11 (0x0800) ist gesetzt", async () => {
-    const zip = await collect(
-      createZipStream(fromEntries([{ path: "ascii.txt", data: fromString("x") }])),
-    );
-    // General Purpose Flags sind im LFH bei Offset 6
-    const flags = readU16LE(zip, 6);
-    expect(flags & 0x0800).toBe(0x0800);
-  });
-});
-
-describe("createZipStream :: format limits (ZIP64-Pre-Check)", () => {
-  // Entry >4 GB Pre-Check ist im Code aktiv (siehe createZipStream Source);
-  // ein echter 4-GB-Body ist im Test nicht allozierbar. Der 65535-Entry-Test
-  // unten deckt die parallele Constraint-Variante ab — Refactor-Schutz.
-
-  test("Archive >65535 Entries wirft mit klarer Begruendung", async () => {
-    // 65535 Entries sind langsam (jedes hat einen Header). 65536 reicht
-    // um den Branch zu triggern. Body kann leer sein — wir testen das
-    // entry-count-cap, nicht den body-cap.
-    async function* manyEntries(): AsyncIterable<ZipEntry> {
-      for (let i = 0; i < 65536; i++) {
-        yield { path: `e${i}.txt`, data: fromBytes(new Uint8Array(0)) };
-      }
-    }
-    await expect(collect(createZipStream(manyEntries()))).rejects.toThrow(
-      /exceeds 65535-entry limit/,
-    );
-  }, 30_000); // 30s timeout — 65536 entries iterieren
-});
-
-// **Plattform-Abhaengigkeit:** dieser describe braucht das `unzip`-
-// shell-binary (Info-ZIP). macOS + Linux haben das standard-installiert,
-// Windows-CI muesste skippen. Repo laeuft aktuell nicht auf Windows-CI,
-// daher kein `test.skipIf` — wenn das je dazukommt, hier Conditional-
-// Skip via `which unzip`-Check ergaenzen.
-describe("createZipStream :: real-decoder roundtrip (unzip shell-binary)", () => {
-  let tmpDir: string;
-
-  beforeEach(async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), "kumiko-zip-test-"));
-  });
-
-  afterEach(async () => {
-    await rm(tmpDir, { recursive: true, force: true });
-  });
-
-  async function spawnUnzip(args: string[]): Promise<{ stdout: string; code: number }> {
-    return new Promise((resolve, reject) => {
-      const proc = spawn("unzip", args);
-      let stdout = "";
-      let stderr = "";
-      proc.stdout.on("data", (d) => (stdout += d.toString()));
-      proc.stderr.on("data", (d) => (stderr += d.toString()));
-      proc.on("close", (code) => resolve({ stdout, code: code ?? -1 }));
-      proc.on("error", reject);
-      // Stderr-Logging fuer Debug bei test-failures
-      void stderr;
-    });
-  }
-
-  test("Info-ZIP unzip -l listet die Entries korrekt", async () => {
-    const zip = await collect(
-      createZipStream(
-        fromEntries([
-          { path: "profile.json", data: fromString('{"name":"Alice"}') },
-          { path: "notes/hello.txt", data: fromString("Hello world") },
-        ]),
-      ),
-    );
-    const zipPath = join(tmpDir, "test.zip");
-    await writeFile(zipPath, zip);
-
-    const { stdout, code } = await spawnUnzip(["-l", zipPath]);
-    expect(code).toBe(0);
-    expect(stdout).toContain("profile.json");
-    expect(stdout).toContain("notes/hello.txt");
-  });
-
-  test("Info-ZIP unzip -p extrahiert exakt den Original-Body", async () => {
-    const original = '{"key":"value","arr":[1,2,3]}';
-    const zip = await collect(
-      createZipStream(fromEntries([{ path: "data.json", data: fromString(original) }])),
-    );
-    const zipPath = join(tmpDir, "data.zip");
-    await writeFile(zipPath, zip);
-
-    const { stdout, code } = await spawnUnzip(["-p", zipPath, "data.json"]);
-    expect(code).toBe(0);
-    expect(stdout).toBe(original);
-  });
-
-  test("Info-ZIP entpackt binary-Daten (UTF-8 + non-ASCII bytes) byte-identisch", async () => {
-    // Mix aus ASCII, UTF-8 (Umlaute), und non-printable Bytes
-    const utf8 = new TextEncoder().encode("Strüße ümläute 🚀");
-    const binary = new Uint8Array([0x00, 0x01, 0xff, 0xfe, 0x80, 0x7f]);
-    const combined = new Uint8Array(utf8.byteLength + binary.byteLength);
-    combined.set(utf8, 0);
-    combined.set(binary, utf8.byteLength);
-
-    const zip = await collect(
-      createZipStream(fromEntries([{ path: "binary.bin", data: fromBytes(combined) }])),
-    );
-    const zipPath = join(tmpDir, "binary.zip");
-    await writeFile(zipPath, zip);
-
-    // Statt unzip -p (Stdout-Decode), entpacke in tmp und lies die
-    // bytes raw zurueck. Das stellt sicher dass keine Encoding-Layer
-    // die Roh-Bytes verfaelscht.
-    const extractDir = join(tmpDir, "out");
-    await spawnUnzip(["-d", extractDir, zipPath]);
-    const { readFile } = await import("node:fs/promises");
-    const extracted = await readFile(join(extractDir, "binary.bin"));
-    expect(Array.from(extracted)).toEqual(Array.from(combined));
-  });
-
-  test("UTF-8 filename mit Umlauten (Bügel.pdf) wird korrekt entpackt", async () => {
-    // Mit UTF-8-Flag (0x0800) im General-Purpose-Flag erwartet Info-ZIP
-    // den filename als UTF-8. Ohne Flag wuerde Info-ZIP CP437
-    // interpretieren, der Umlaut waere Mojibake. Pinst dass DACH-User
-    // mit Umlaut-Filenames sauber exportiert werden.
-    const zip = await collect(
-      createZipStream(fromEntries([{ path: "Bügel.pdf", data: fromString("umlaut-content") }])),
-    );
-    const zipPath = join(tmpDir, "umlaut.zip");
-    await writeFile(zipPath, zip);
-
-    const extractDir = join(tmpDir, "out");
-    await spawnUnzip(["-d", extractDir, zipPath]);
-
-    const { readFile, readdir } = await import("node:fs/promises");
-    const entries = await readdir(extractDir);
-    expect(entries).toContain("Bügel.pdf");
-    expect(await readFile(join(extractDir, "Bügel.pdf"), "utf8")).toBe("umlaut-content");
-  });
-
-  test("3-Entry-ZIP: alle Entries entpackbar + byte-identisch", async () => {
-    const entries: ZipEntry[] = [
-      { path: "a.json", data: fromString('{"a":1}') },
-      { path: "subdir/b.json", data: fromString('{"b":2}') },
-      { path: "subdir/nested/c.json", data: fromString('{"c":3}') },
-    ];
-    const zip = await collect(createZipStream(fromEntries(entries)));
-    const zipPath = join(tmpDir, "multi.zip");
-    await writeFile(zipPath, zip);
-
-    const extractDir = join(tmpDir, "out");
-    await spawnUnzip(["-d", extractDir, zipPath]);
-
-    const { readFile } = await import("node:fs/promises");
-    expect(await readFile(join(extractDir, "a.json"), "utf8")).toBe('{"a":1}');
-    expect(await readFile(join(extractDir, "subdir/b.json"), "utf8")).toBe('{"b":2}');
-    expect(await readFile(join(extractDir, "subdir/nested/c.json"), "utf8")).toBe('{"c":3}');
-  });
-});
-
-describe("createZipStream :: mtime in UTC (Audit-Drift-Schutz)", () => {
-  test("mtime wird als UTC encoded, nicht als lokale Zeitzone", async () => {
-    // 2026-05-09 14:30:00 UTC = 16:30:00 CEST. Wenn die Implementation
-    // auf lokal-Zeitzone (CEST-Server) liefe, kaeme als DOS-Time 16:30
-    // raus. Wir pinnen 14:30 — UTC.
-    const fixedUtc = getTemporal().Instant.fromEpochMilliseconds(Date.UTC(2026, 4, 9, 14, 30, 0)); // 2026-05-09 14:30:00 UTC
-    const zip = await collect(
-      createZipStream(fromEntries([{ path: "x.txt", data: fromString("x"), mtime: fixedUtc }])),
-    );
-    // DOS time im LFH bei Offset 10, DOS date bei Offset 12
-    const dosTime = readU16LE(zip, 10);
-    const dosDate = readU16LE(zip, 12);
-    // DOS time: bits 11-15=hour, 5-10=minute, 0-4=second/2
-    const hour = (dosTime >> 11) & 0x1f;
-    const minute = (dosTime >> 5) & 0x3f;
-    expect(hour).toBe(14);
-    expect(minute).toBe(30);
-    // DOS date: bits 9-15=year-1980, 5-8=month, 0-4=day
-    const year = ((dosDate >> 9) & 0x7f) + 1980;
-    const month = (dosDate >> 5) & 0x0f;
-    const day = dosDate & 0x1f;
-    expect(year).toBe(2026);
-    expect(month).toBe(5);
-    expect(day).toBe(9);
-  });
-});
-
-describe("createZipStream :: streaming property", () => {
-  test("Lazy entries (async generator mit setTimeout) werden korrekt verarbeitet", async () => {
-    async function* lazyEntries(): AsyncIterable<ZipEntry> {
-      await new Promise((r) => setTimeout(r, 5));
-      yield { path: "lazy1.txt", data: fromString("delayed1") };
-      await new Promise((r) => setTimeout(r, 5));
-      yield { path: "lazy2.txt", data: fromString("delayed2") };
-    }
-
-    const zip = await collect(createZipStream(lazyEntries()));
-    const eocdStart = zip.byteLength - 22;
-    expect(readU16LE(zip, eocdStart + 8)).toBe(2);
-  });
-
-  test("Lazy chunks innerhalb Entry: AsyncIterable<Uint8Array> mit setTimeout", async () => {
-    async function* lazyChunks(): AsyncIterable<Uint8Array> {
-      await new Promise((r) => setTimeout(r, 2));
-      yield new TextEncoder().encode("chunk1-");
-      await new Promise((r) => setTimeout(r, 2));
-      yield new TextEncoder().encode("chunk2");
-    }
-
-    const zip = await collect(
-      createZipStream(fromEntries([{ path: "chunked.txt", data: lazyChunks() }])),
-    );
-
-    // Body folgt nach LFH (30 + filename)
-    const filenameLen = readU16LE(zip, 26);
-    const bodyStart = 30 + filenameLen;
-    const totalSize = readU32LE(zip, 22); // uncompressed size
-    const bodyBytes = zip.slice(bodyStart, bodyStart + totalSize);
-    expect(new TextDecoder().decode(bodyBytes)).toBe("chunk1-chunk2");
-  });
-});

package/src/files/content-disposition.ts

@@ -1,55 +0,0 @@
-// RFC-6266 + RFC-5987 compliant Content-Disposition builder.
-//
-// fileName reaches this module from the client's multipart upload — it is
-// effectively attacker-controlled. A name like
-// `foo.pdf"; filename*=utf-8''evil.exe` would break the `filename="..."`
-// header quoting and inject a second parameter if we interpolated the raw
-// string. Two-step fix:
-//
-//   1. ASCII fallback for `filename="..."` — strip anything outside a safe
-//      token set, keeping the name readable for legacy clients that don't
-//      understand RFC 5987.
-//   2. Percent-encoded UTF-8 for `filename*=UTF-8''...` — the modern
-//      parameter that every current browser honours. RFC 5987 requires a
-//      handful of reserved chars that encodeURIComponent leaves alone
-//      ('()*) to also be escaped.
-//
-// Lives in its own module so the sanitisation is unit-testable in
-// isolation — the HTTP route exercises integration; edge cases around
-// encoding + fallback live in content-disposition.test.ts.
-
-const MAX_FALLBACK_LENGTH = 100;
-const SAFE_FALLBACK_CHARS = /[^A-Za-z0-9.\-_()]/g;
-const RFC_5987_EXTRA_ESCAPES = /['()*]/g;
-
-export function buildContentDispositionHeader(fileName: string): string {
-  const asciiFallback = toAsciiFallback(fileName);
-  const encoded = encodeRFC5987(fileName);
-  return `attachment; filename="${asciiFallback}"; filename*=UTF-8''${encoded}`;
-}
-
-// Collapse everything outside a safe token set (letters, digits, dot, dash,
-// underscore, parens) to underscore. Bounded length so a giant client-
-// supplied name can't balloon the header.
-//
-// Falls back to "download" in two cases: (1) the stripped result is empty,
-// and (2) nothing alphanumeric survived — a filename like "_______.png" is
-// legal but useless. "download" is readable; the original bytes still
-// reach the browser losslessly via filename* in the surrounding header.
-export function toAsciiFallback(name: string): string {
-  const stripped = name.replace(SAFE_FALLBACK_CHARS, "_").slice(0, MAX_FALLBACK_LENGTH);
-  if (stripped.length === 0) return "download";
-  if (!/[A-Za-z0-9]/.test(stripped)) return "download";
-  return stripped;
-}
-
-// encodeURIComponent handles the UTF-8 → percent-encoding step but leaves
-// a handful of characters unescaped that RFC 5987 calls out as reserved
-// ( ' ( ) * ). Escape those explicitly so the output is strictly
-// conformant and safe to drop into the `ext-value` production.
-export function encodeRFC5987(value: string): string {
-  return encodeURIComponent(value).replace(
-    RFC_5987_EXTRA_ESCAPES,
-    (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`,
-  );
-}