chore: import upstream snapshot with attribution

tests/unit/compression/stacked-async.test.ts

@@ -0,0 +1,175 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  applyStackedCompression,
+  applyStackedCompressionAsync,
+} from "../../../open-sse/services/compression/index.ts";
+import {
+  registerCompressionEngine,
+  unregisterCompressionEngine,
+} from "../../../open-sse/services/compression/engines/registry.ts";
+import type {
+  CompressionEngine,
+  CompressionEngineTarget,
+} from "../../../open-sse/services/compression/engines/types.ts";
+import type {
+  CompressionPipelineStep,
+  CompressionResult,
+} from "../../../open-sse/services/compression/types.ts";
+
+const FS = "fake-sync-engine";
+const FA = "fake-async-engine";
+
+/**
+ * Transform that tags every user message content with `|<id>` so the test can
+ * assert both that the engine ran and the order in which engines ran.
+ */
+function tag(id: string, body: Record<string, unknown>): CompressionResult {
+  const messages = (body.messages as Array<{ role: string; content: string }>) ?? [];
+  // Tag the user message; drop any padding (non-user) content so the stacked body
+  // genuinely shrinks and the #5527 (T02) inflation guard does not revert it.
+  const next = messages.map((m) =>
+    m.role === "user" ? { ...m, content: `${m.content}|${id}` } : { ...m, content: "" }
+  );
+  return {
+    body: { ...body, messages: next },
+    compressed: true,
+    stats: {
+      originalTokens: 10,
+      compressedTokens: 9,
+      savingsPercent: 10,
+      techniquesUsed: [id],
+      mode: "stacked",
+      timestamp: 0,
+      durationMs: 0.5,
+    },
+  };
+}
+
+function makeEngine(id: string, opts: { async?: boolean } = {}): CompressionEngine {
+  const base: CompressionEngine = {
+    id,
+    name: id,
+    description: id,
+    icon: "x",
+    targets: ["messages"] as CompressionEngineTarget[],
+    stackable: true,
+    stackPriority: 0,
+    metadata: {
+      id,
+      name: id,
+      description: id,
+      inputScope: "messages",
+      targetLatencyMs: 1,
+      supportsPreview: false,
+      stable: true,
+    },
+    // Async-only engines provide a graceful sync pass-through so the legacy
+    // sync stacked path never crashes and simply skips the async-only work.
+    apply: opts.async
+      ? (body) => ({ body, compressed: false, stats: null })
+      : (body) => tag(id, body),
+    compress: (body) => tag(id, body),
+    getConfigSchema: () => [],
+    validateConfig: () => ({ valid: true, errors: [] }),
+  };
+  if (opts.async) {
+    return { ...base, applyAsync: async (body) => tag(id, body) };
+  }
+  return base;
+}
+
+function userContent(result: CompressionResult): string {
+  const messages = result.body.messages as Array<{ role: string; content: string }>;
+  return messages.find((m) => m.role === "user")!.content;
+}
+
+function pipeline(...ids: string[]): CompressionPipelineStep[] {
+  return ids.map((engine) => ({ engine })) as unknown as CompressionPipelineStep[];
+}
+
+// Fixture body with a large droppable padding message: engines drop it (see `tag`) so the
+// final stacked body shrinks and the #5527 (T02) inflation guard keeps the tagged output
+// instead of reverting it. These tests assert engine ORDER/advancement, not compression
+// ratios, so the body must realistically shrink for the tag assertions to survive the guard.
+const PADDING = "padding tokens ".repeat(40);
+function mkBody(): { messages: Array<{ role: string; content: string }> } {
+  return {
+    messages: [
+      { role: "user", content: "hello" },
+      { role: "assistant", content: PADDING },
+    ],
+  };
+}
+
+describe("stacked compression — async interface (H10)", () => {
+  before(() => {
+    registerCompressionEngine(makeEngine(FS));
+    registerCompressionEngine(makeEngine(FA, { async: true }));
+  });
+  after(() => {
+    unregisterCompressionEngine(FS);
+    unregisterCompressionEngine(FA);
+  });
+
+  it("runs a mixed sync+async pipeline in pipeline order", async () => {
+    const body = mkBody();
+    const result = await applyStackedCompressionAsync(body, pipeline(FS, FA));
+
+    assert.equal(userContent(result), "hello|fake-sync-engine|fake-async-engine");
+    assert.equal(result.compressed, true);
+    assert.equal(result.stats?.engine, "stacked");
+    assert.deepEqual(
+      result.stats?.engineBreakdown?.map((e) => e.engine),
+      [FS, FA]
+    );
+  });
+
+  it("preserves order when the async engine runs first", async () => {
+    const body = mkBody();
+    const result = await applyStackedCompressionAsync(body, pipeline(FA, FS));
+
+    assert.equal(userContent(result), "hello|fake-async-engine|fake-sync-engine");
+    assert.deepEqual(
+      result.stats?.engineBreakdown?.map((e) => e.engine),
+      [FA, FS]
+    );
+  });
+
+  it("async path yields the same result as sync path for sync-only engines", async () => {
+    const body = mkBody();
+    const asyncResult = await applyStackedCompressionAsync(body, pipeline(FS));
+    const syncResult = applyStackedCompression(body, pipeline(FS));
+
+    assert.deepEqual(asyncResult.body, syncResult.body);
+    assert.equal(userContent(asyncResult), "hello|fake-sync-engine");
+  });
+
+  it("legacy sync path gracefully skips async-only work without crashing", () => {
+    const body = mkBody();
+    const result = applyStackedCompression(body, pipeline(FA));
+
+    // The async-only engine's sync apply() is a pass-through: no transform.
+    assert.equal(userContent(result), "hello");
+  });
+
+  it("regression: real rtk→caveman stacked pipeline still works (sync)", () => {
+    const body = {
+      messages: [
+        { role: "tool", content: Array.from({ length: 8 }, () => "same noisy line").join("\n") },
+        { role: "user", content: "Explain the authentication configuration in detail please" },
+      ],
+    };
+    const result = applyStackedCompression(body, [
+      { engine: "rtk", intensity: "standard" },
+      { engine: "caveman", intensity: "full" },
+    ]);
+
+    assert.equal(result.stats?.engine, "stacked");
+    assert.deepEqual(
+      result.stats?.engineBreakdown?.map((e) => e.engine),
+      ["rtk", "caveman"]
+    );
+  });
+});