@stigmer/runner 3.12.8 → 3.13.0

package/src/__test-utils__/zip-fixtures.ts

@@ -1,206 +0,0 @@
-/**
- * Shared ZIP fixture builder for runner unit tests.
- *
- * Emits complete, real-shaped archives — local file headers (optionally
- * streaming-style, the Go stdlib writer's default), payloads, central
- * directory, and EOCD — because that is the only shape that can reach the
- * runner: both editions' skill push gates validate artifacts with
- * central-directory-based readers (see zip-extract.ts's module doc and
- * design record 017). Earlier fixtures emitted local headers only, a
- * shape no real ZIP writer produces, and were coupled to the old parser's
- * front-to-back walk.
- *
- * Mirrors the conformance suite's `zipFilesStreaming()`
- * (test/conformance/src/support/skills.ts) so unit fixtures and
- * cross-edition fixtures share one shape.
- *
- * Lives in src/__test-utils__/ so `tsc --noEmit` covers it while
- * tsconfig.build.json keeps it out of dist/.
- */
-
-import { deflateRawSync } from "node:zlib";
-
-export interface ZipFixtureFile {
-  name: string;
-  /** Text content is UTF-8 encoded; pass bytes directly for binary payloads. */
-  content: string | Uint8Array;
-  /** Compression method for the entry. Defaults to stored. */
-  method?: "stored" | "deflated";
-  /**
-   * Emit the entry the way Go's archive/zip does by default: general-purpose
-   * flag bit 3 set, zeroed sizes in the local header, and a trailing data
-   * descriptor (with the conventional signature) carrying the real values.
-   */
-  streaming?: boolean;
-  /**
-   * Lie about the entry's uncompressed size everywhere the writer would
-   * declare it (local header, data descriptor, central directory). Models a
-   * crafted archive whose declarations disagree with its actual payload —
-   * the input class the attachment injector's declared-size enforcement
-   * exists to reject (issue #567).
-   */
-  declaredUncompressedSize?: number;
-}
-
-export interface ZipFixtureOptions {
-  /** Trailing archive comment appended after the EOCD record. */
-  comment?: string;
-  /**
-   * Drop the central directory and EOCD, leaving only local headers and
-   * payloads. No real ZIP writer produces this shape — it models a download
-   * truncated before the archive's index.
-   */
-  omitCentralDirectory?: boolean;
-}
-
-/** Build a ZIP archive from path + content pairs. */
-export function buildZip(files: ZipFixtureFile[], options?: ZipFixtureOptions): Uint8Array {
-  const out = new ByteWriter();
-
-  interface WrittenEntry {
-    nameBytes: Uint8Array;
-    payload: Uint8Array;
-    declaredUncompressed: number;
-    crc: number;
-    flags: number;
-    method: number;
-    localHeaderOffset: number;
-  }
-  const written: WrittenEntry[] = [];
-
-  for (const file of files) {
-    const contentBytes =
-      typeof file.content === "string" ? new TextEncoder().encode(file.content) : file.content;
-    const deflated = file.method === "deflated";
-    const payload = deflated ? new Uint8Array(deflateRawSync(contentBytes)) : contentBytes;
-    const entry: WrittenEntry = {
-      nameBytes: new TextEncoder().encode(file.name),
-      payload,
-      declaredUncompressed: file.declaredUncompressedSize ?? contentBytes.length,
-      crc: crc32(contentBytes),
-      flags: file.streaming ? 0x0008 : 0,
-      method: deflated ? 8 : 0,
-      localHeaderOffset: out.length,
-    };
-    written.push(entry);
-
-    out.u32(0x04034b50); // local file header signature
-    out.u16(20); // version needed to extract
-    out.u16(entry.flags);
-    out.u16(entry.method);
-    out.u16(0); // mod time
-    out.u16(0); // mod date
-    out.u32(file.streaming ? 0 : entry.crc);
-    out.u32(file.streaming ? 0 : payload.length);
-    out.u32(file.streaming ? 0 : entry.declaredUncompressed);
-    out.u16(entry.nameBytes.length);
-    out.u16(0); // extra field length
-    out.raw(entry.nameBytes);
-    out.raw(payload);
-
-    if (file.streaming) {
-      out.u32(0x08074b50); // data descriptor signature (Go writes it)
-      out.u32(entry.crc);
-      out.u32(payload.length);
-      out.u32(entry.declaredUncompressed);
-    }
-  }
-
-  if (options?.omitCentralDirectory) {
-    return out.toUint8Array();
-  }
-
-  const centralDirectoryOffset = out.length;
-  for (const entry of written) {
-    out.u32(0x02014b50); // central directory record signature
-    out.u16(20); // version made by
-    out.u16(20); // version needed to extract
-    out.u16(entry.flags);
-    out.u16(entry.method);
-    out.u16(0); // mod time
-    out.u16(0); // mod date
-    out.u32(entry.crc);
-    out.u32(entry.payload.length);
-    out.u32(entry.declaredUncompressed);
-    out.u16(entry.nameBytes.length);
-    out.u16(0); // extra field length
-    out.u16(0); // comment length
-    out.u16(0); // disk number start
-    out.u16(0); // internal attributes
-    out.u32(0); // external attributes
-    out.u32(entry.localHeaderOffset);
-    out.raw(entry.nameBytes);
-  }
-  const centralDirectorySize = out.length - centralDirectoryOffset;
-
-  const commentBytes = new TextEncoder().encode(options?.comment ?? "");
-  out.u32(0x06054b50); // EOCD signature
-  out.u16(0); // disk number
-  out.u16(0); // disk with central directory
-  out.u16(written.length); // entries on this disk
-  out.u16(written.length); // total entries
-  out.u32(centralDirectorySize);
-  out.u32(centralDirectoryOffset);
-  out.u16(commentBytes.length);
-  out.raw(commentBytes);
-
-  return out.toUint8Array();
-}
-
-// Chunked assembly instead of a number[]-per-byte accumulator: fixtures at
-// the injector's 100 MB zip-bomb limit are built from payload-sized chunks,
-// which a per-byte spread-push cannot survive (argument-count overflow).
-class ByteWriter {
-  private readonly chunks: Uint8Array[] = [];
-  private size = 0;
-
-  get length(): number {
-    return this.size;
-  }
-
-  u16(v: number): void {
-    this.raw(new Uint8Array([v & 0xff, (v >>> 8) & 0xff]));
-  }
-
-  u32(v: number): void {
-    this.raw(new Uint8Array([v & 0xff, (v >>> 8) & 0xff, (v >>> 16) & 0xff, (v >>> 24) & 0xff]));
-  }
-
-  raw(b: Uint8Array): void {
-    this.chunks.push(b);
-    this.size += b.length;
-  }
-
-  toUint8Array(): Uint8Array {
-    const result = new Uint8Array(this.size);
-    let offset = 0;
-    for (const chunk of this.chunks) {
-      result.set(chunk, offset);
-      offset += chunk.length;
-    }
-    return result;
-  }
-}
-
-// Standard CRC-32 (IEEE 802.3, the ZIP checksum), table-driven so fixtures
-// at the injector's 100 MB limit stay cheap to build. Semantically identical
-// to the conformance suite's inline bit-loop helper.
-const CRC_TABLE = (() => {
-  const table = new Uint32Array(256);
-  for (let n = 0; n < 256; n++) {
-    let c = n;
-    for (let bit = 0; bit < 8; bit++) {
-      c = (c >>> 1) ^ (0xedb88320 & -(c & 1));
-    }
-    table[n] = c;
-  }
-  return table;
-})();
-
-function crc32(data: Uint8Array): number {
-  let crc = 0xffffffff;
-  for (let i = 0; i < data.length; i++) {
-    crc = (crc >>> 8) ^ CRC_TABLE[(crc ^ data[i]!) & 0xff]!;
-  }
-  return (crc ^ 0xffffffff) >>> 0;
-}

package/src/__tests__/claimcheck-codec.test.ts

@@ -1,256 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { ClaimcheckPayloadCodec } from "../claimcheck/payload-codec.js";
-import { compress } from "../claimcheck/compressor.js";
-import type { ClaimcheckConfig } from "../claimcheck/config.js";
-import { makeInMemoryArtifactStorage } from "../__test-utils__/fake-artifact-storage.js";
-import type { Payload } from "@temporalio/common";
-
-function makeConfig(overrides: Partial<ClaimcheckConfig> = {}): ClaimcheckConfig {
-  return {
-    enabled: true,
-    thresholdBytes: 1024,
-    compressionEnabled: true,
-    keyPrefix: "claimcheck/",
-    ...overrides,
-  };
-}
-
-function makeStorage() {
-  // The canonical in-memory double; `uploads` aliases its backing Map so the
-  // existing `storage.uploads.*` assertions keep working, and `download` reads
-  // straight from what `encode` uploaded (no fetch to stub).
-  const { storage, blobs } = makeInMemoryArtifactStorage();
-  return Object.assign(storage, { uploads: blobs });
-}
-
-function makePayload(data: string | Buffer): Payload {
-  const buf = typeof data === "string" ? Buffer.from(data) : data;
-  return {
-    metadata: { encoding: Buffer.from("binary/plain") },
-    data: buf,
-  };
-}
-
-function makeLargePayload(sizeBytes: number): Payload {
-  const buf = Buffer.alloc(sizeBytes, "x");
-  return {
-    metadata: { encoding: Buffer.from("binary/plain") },
-    data: buf,
-  };
-}
-
-describe("ClaimcheckPayloadCodec", () => {
-  let storage: ReturnType<typeof makeStorage>;
-  let codec: ClaimcheckPayloadCodec;
-
-  beforeEach(() => {
-    storage = makeStorage();
-    codec = new ClaimcheckPayloadCodec(storage, makeConfig());
-  });
-
-  describe("encode", () => {
-    it("passes through payloads below threshold unchanged", async () => {
-      const payload = makePayload("small data");
-      const [result] = await codec.encode([payload]);
-      expect(result).toBe(payload);
-      expect(storage.uploads.size).toBe(0);
-    });
-
-    it("passes through empty payloads", async () => {
-      const payload: Payload = { metadata: {}, data: undefined };
-      const [result] = await codec.encode([payload]);
-      expect(result).toBe(payload);
-    });
-
-    it("offloads payloads at or above threshold", async () => {
-      const payload = makeLargePayload(1024);
-      const [result] = await codec.encode([payload]);
-
-      expect(result).not.toBe(payload);
-      expect(storage.uploads.size).toBe(1);
-
-      const markerMeta = result.metadata?.["encoding"];
-      expect(Buffer.from(markerMeta!).toString()).toBe("binary/claimcheck");
-
-      const marker = JSON.parse(Buffer.from(result.data!).toString());
-      expect(marker.key).toMatch(/^claimcheck\//);
-      expect(marker.size).toBe(1024);
-      expect(marker.compressed).toBe(true);
-    });
-
-    it("skips compression when it does not reduce size", async () => {
-      const randomBuf = Buffer.from(
-        Array.from({ length: 1024 }, () => Math.floor(Math.random() * 256)),
-      );
-      const payload: Payload = {
-        metadata: { encoding: Buffer.from("binary/plain") },
-        data: randomBuf,
-      };
-
-      const compressedSize = compress(randomBuf).length;
-      if (compressedSize >= randomBuf.length) {
-        const [result] = await codec.encode([payload]);
-        const marker = JSON.parse(Buffer.from(result.data!).toString());
-        expect(marker.compressed).toBe(false);
-
-        const uploaded = storage.uploads.values().next().value!;
-        expect(uploaded.length).toBe(randomBuf.length);
-      }
-    });
-
-    it("does not compress when compression is disabled", async () => {
-      codec = new ClaimcheckPayloadCodec(
-        storage,
-        makeConfig({ compressionEnabled: false }),
-      );
-      const payload = makeLargePayload(1024);
-      const [result] = await codec.encode([payload]);
-
-      const marker = JSON.parse(Buffer.from(result.data!).toString());
-      expect(marker.compressed).toBe(false);
-
-      const uploaded = storage.uploads.values().next().value!;
-      expect(uploaded.length).toBe(1024);
-    });
-
-    it("handles multiple payloads in a batch", async () => {
-      const small = makePayload("tiny");
-      const large = makeLargePayload(2048);
-
-      const results = await codec.encode([small, large]);
-      expect(results[0]).toBe(small);
-      expect(results[1]).not.toBe(large);
-      expect(storage.uploads.size).toBe(1);
-    });
-
-    it("uses configured key prefix", async () => {
-      codec = new ClaimcheckPayloadCodec(
-        storage,
-        makeConfig({ keyPrefix: "custom-prefix/" }),
-      );
-      const payload = makeLargePayload(1024);
-      const [result] = await codec.encode([payload]);
-
-      const marker = JSON.parse(Buffer.from(result.data!).toString());
-      expect(marker.key).toMatch(/^custom-prefix\//);
-    });
-  });
-
-  describe("decode", () => {
-    it("passes through non-claimcheck payloads unchanged", async () => {
-      const payload = makePayload("normal data");
-      const [result] = await codec.decode([payload]);
-      expect(result).toBe(payload);
-    });
-
-    it("retrieves and decompresses offloaded payloads (round-trip)", async () => {
-      const original = makeLargePayload(2048);
-      const [encoded] = await codec.encode([original]);
-
-      // decode reads back through storage.download from what encode uploaded.
-      const [decoded] = await codec.decode([encoded]);
-      expect(Buffer.from(decoded.data!)).toEqual(original.data);
-    });
-
-    it("restores the original payload metadata (round-trip)", async () => {
-      // The restored payload must carry its ORIGINAL encoding, not the
-      // marker's binary/claimcheck — otherwise no payload converter can
-      // interpret it and composition with the encryption codec breaks.
-      const original: Payload = {
-        metadata: {
-          encoding: Buffer.from("json/plain"),
-          "custom-key": Buffer.from("custom-value"),
-        },
-        data: Buffer.alloc(2048, "y"),
-      };
-
-      const [encoded] = await codec.encode([original]);
-      const [decoded] = await codec.decode([encoded]);
-
-      expect(Buffer.from(decoded.metadata!["encoding"]!).toString()).toBe("json/plain");
-      expect(Buffer.from(decoded.metadata!["custom-key"]!).toString()).toBe("custom-value");
-      expect(Buffer.from(decoded.data!)).toEqual(original.data);
-    });
-
-    it("decodes legacy markers written before metadata preservation", async () => {
-      const original = makeLargePayload(2048);
-      const [encoded] = await codec.encode([original]);
-
-      // Simulate a pre-fix marker: strip the metadata field.
-      const marker = JSON.parse(Buffer.from(encoded.data!).toString());
-      delete marker.metadata;
-      const legacy: Payload = {
-        metadata: encoded.metadata,
-        data: Buffer.from(JSON.stringify(marker)),
-      };
-
-      const [decoded] = await codec.decode([legacy]);
-      expect(Buffer.from(decoded.data!)).toEqual(original.data);
-    });
-
-    it("retrieves uncompressed payloads correctly", async () => {
-      codec = new ClaimcheckPayloadCodec(
-        storage,
-        makeConfig({ compressionEnabled: false }),
-      );
-
-      const original = makeLargePayload(1500);
-      const [encoded] = await codec.encode([original]);
-
-      const [decoded] = await codec.decode([encoded]);
-      expect(Buffer.from(decoded.data!)).toEqual(original.data);
-    });
-
-    it("wraps a download failure with the claimcheck error contract", async () => {
-      const encoded: Payload = {
-        metadata: { encoding: Buffer.from("binary/claimcheck") },
-        data: Buffer.from(JSON.stringify({
-          key: "claimcheck/missing",
-          size: 100,
-          compressed: false,
-        })),
-      };
-
-      // Drive the failure through the port; the proxy download surfaces the HTTP
-      // status, which the codec must preserve in its wrapped, key-scoped message.
-      storage.download.mockRejectedValueOnce(
-        new Error("Artifact download failed (HTTP 404) for key 'claimcheck/missing'"),
-      );
-
-      await expect(codec.decode([encoded])).rejects.toThrow(
-        /Claimcheck retrieve failed for key claimcheck\/missing.*HTTP 404/,
-      );
-    });
-  });
-
-  describe("threshold boundary", () => {
-    it("does NOT offload at threshold - 1", async () => {
-      const payload = makeLargePayload(1023);
-      const [result] = await codec.encode([payload]);
-      expect(result).toBe(payload);
-    });
-
-    it("offloads at exactly threshold", async () => {
-      const payload = makeLargePayload(1024);
-      const [result] = await codec.encode([payload]);
-      expect(result).not.toBe(payload);
-    });
-
-    it("offloads above threshold", async () => {
-      const payload = makeLargePayload(1025);
-      const [result] = await codec.encode([payload]);
-      expect(result).not.toBe(payload);
-    });
-  });
-
-  describe("compressor", () => {
-    it("compresses and decompresses correctly", async () => {
-      const { compress: c, decompress: d } = await import("../claimcheck/compressor.js");
-      const input = Buffer.from("hello world ".repeat(100));
-      const compressed = c(input);
-      expect(compressed.length).toBeLessThan(input.length);
-      const decompressed = d(compressed);
-      expect(decompressed).toEqual(input);
-    });
-  });
-});