agenticreplay 0.1.0 → 0.1.2

package/packages/proxy/test/forward.test.ts

@@ -1,306 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import type { NetExchange } from '../src/intercept.js';
-import { createProxy } from '../src/server.js';
-import { decodeForwardPath, forwardBasePath } from '../src/forward.js';
-
-const closers: Array<() => Promise<void>> = [];
-afterEach(async () => {
-  while (closers.length) await closers.pop()!();
-});
-
-/**
- * A `/forward/` path is how an adapter hands the proxy a request whose real destination agenticreplay
- * rewrote away: the harness's base URL was pointed here with the true base encoded into the path,
- * so every request arrives naming where it was headed. The assertions are about restoring that
- * faithfully — same bytes, same path, same wire shape — and about the prefix never firing on a
- * path that merely looks like one.
- */
-
-const ZEN_GO = 'https://opencode.ai/zen/go/v1';
-
-describe('decodeForwardPath', () => {
-  it('decodes an encoded base and keeps the appended path', () => {
-    const decoded = decodeForwardPath(`${forwardBasePath(ZEN_GO)}/chat/completions`);
-    expect(decoded).toEqual({ base: ZEN_GO, path: '/chat/completions' });
-  });
-
-  it('decodes a base with no appended path to the root', () => {
-    expect(decodeForwardPath(forwardBasePath('https://api.example.com'))).toEqual({
-      base: 'https://api.example.com',
-      path: '/',
-    });
-  });
-
-  it('strips a trailing slash from the base', () => {
-    const decoded = decodeForwardPath(`${forwardBasePath(`${ZEN_GO}/`)}/chat/completions`);
-    expect(decoded?.base).toBe(ZEN_GO);
-  });
-
-  it('refuses a path that only begins with the prefix', () => {
-    expect(decodeForwardPath('/forward/plain')).toBeUndefined();
-    expect(decodeForwardPath('/forward/https%3A%2F%2F')).toBeUndefined();
-    expect(decodeForwardPath('/forward/%E0%A4%A')).toBeUndefined();
-    expect(decodeForwardPath('/forward/a%2Fb/v1/embeddings')).toBeUndefined();
-  });
-
-  it('refuses anything that is not a bare http(s) base', () => {
-    expect(decodeForwardPath(forwardBasePath('ftp://opencode.ai/x'))).toBeUndefined();
-    expect(
-      decodeForwardPath(forwardBasePath('https://user:pw@opencode.ai/zen/go/v1')),
-    ).toBeUndefined();
-    expect(decodeForwardPath(forwardBasePath('https://opencode.ai/x?key=1'))).toBeUndefined();
-    expect(decodeForwardPath(forwardBasePath('https://opencode.ai/x#frag'))).toBeUndefined();
-  });
-});
-
-function stubUpstream(reply: unknown, status = 200) {
-  const calls: { url: string; body: string; headers: Record<string, string> }[] = [];
-  const fetchImpl = (async (url: string | URL | Request, init: RequestInit = {}) => {
-    calls.push({
-      url: String(url),
-      body: String(init.body ?? ''),
-      headers: (init.headers ?? {}) as Record<string, string>,
-    });
-    return new Response(JSON.stringify(reply), {
-      status,
-      headers: { 'content-type': 'application/json' },
-    });
-  }) as unknown as typeof fetch;
-  return { calls, fetchImpl };
-}
-
-async function post(url: string, body: unknown, headers: Record<string, string> = {}) {
-  const res = await fetch(url, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json', ...headers },
-    body: JSON.stringify(body),
-  });
-  return { status: res.status, text: await res.text() };
-}
-
-const TURN = {
-  model: 'glm-5.3-flash',
-  messages: [{ role: 'user', content: 'hello' }],
-};
-
-describe('record mode — a forwarded origin', () => {
-  it('forwards to the base the request named and records the real path', async () => {
-    const up = stubUpstream({
-      id: 'c1',
-      choices: [{ message: { role: 'assistant', content: 'hi' } }],
-    });
-    const proxy = await createProxy({ mode: 'record', fetchImpl: up.fetchImpl });
-    closers.push(proxy.close);
-
-    const res = await post(`${proxy.url}${forwardBasePath(ZEN_GO)}/chat/completions`, TURN);
-
-    expect(res.status).toBe(200);
-    expect(up.calls[0]!.url).toBe(`${ZEN_GO}/chat/completions`);
-    const exchange = proxy.exchanges()[0]!;
-    expect(exchange.dialect).toBe('openai');
-    expect(exchange.path).toBe('/chat/completions');
-    expect(exchange.canonicalRequest.model).toBe('glm-5.3-flash');
-  });
-
-  it('keeps the caller auth header upstream and out of the trace', async () => {
-    const up = stubUpstream({ id: 'c1', choices: [] });
-    const proxy = await createProxy({ mode: 'record', fetchImpl: up.fetchImpl });
-    closers.push(proxy.close);
-
-    await post(`${proxy.url}${forwardBasePath(ZEN_GO)}/chat/completions`, TURN, {
-      authorization: 'Bearer sk-live-9',
-    });
-
-    expect(up.calls[0]!.headers['authorization']).toBe('Bearer sk-live-9');
-    expect(JSON.stringify(proxy.exchanges()[0])).not.toContain('sk-live-9');
-  });
-
-  it('outranks a configured gateway on a live call, because the request names its own destination', async () => {
-    // A gateway picked up from `agenticreplay setup` is a default for calls agenticreplay would otherwise have to
-    // guess at. A forwarded request announces where it was headed — and the recorded run that
-    // exposed this answered every turn with the gateway's website 404 page, because
-    // `https://gateway/chat/completions` is not an API path anything serves.
-    const up = stubUpstream({ id: 'c1', choices: [] });
-    const proxy = await createProxy({
-      mode: 'record',
-      fetchImpl: up.fetchImpl,
-      upstream: { openai: 'https://api.orcarouter.ai' },
-    });
-    closers.push(proxy.close);
-
-    const res = await post(`${proxy.url}${forwardBasePath(ZEN_GO)}/chat/completions`, TURN);
-
-    expect(res.status).toBe(200);
-    expect(up.calls[0]!.url).toBe(`${ZEN_GO}/chat/completions`);
-  });
-
-  it('does not carry a gateway key to the destination the request named', async () => {
-    // `upstreamHeaders` are the gateway's credential. Attaching them to every outbound call used
-    // to be harmless because every outbound call went to the gateway; with forwarded requests
-    // going to their own origin, it would hand a third party a key they were never meant to see.
-    const up = stubUpstream({ id: 'c1', choices: [] });
-    const proxy = await createProxy({
-      mode: 'record',
-      fetchImpl: up.fetchImpl,
-      upstream: { openai: 'https://api.orcarouter.ai' },
-      upstreamHeaders: { authorization: 'Bearer sk-gateway-key' },
-      upstreamHeadersOrigin: 'https://api.orcarouter.ai',
-    });
-    closers.push(proxy.close);
-
-    await post(`${proxy.url}${forwardBasePath(ZEN_GO)}/chat/completions`, TURN);
-
-    expect(up.calls[0]!.url).toBe(`${ZEN_GO}/chat/completions`);
-    expect(up.calls[0]!.headers['authorization']).toBeUndefined();
-  });
-
-  it('normalizes the path for an origin agenticreplay chose, so a gateway sees its version segment', async () => {
-    // A bare base url (no `/v1`) reaches this proxy as `/chat/completions`; a gateway handed that
-    // without the version segment answers 404. The dialect's own path is what an origin agenticreplay
-    // picked expects — which is also what an env-redirected request already carries.
-    const up = stubUpstream({ id: 'c1', choices: [] });
-    const proxy = await createProxy({
-      mode: 'hybrid',
-      exchanges: [],
-      forkAt: 0,
-      forkModel: 'gpt-5.6-luna',
-      fetchImpl: up.fetchImpl,
-      upstream: { openai: 'https://api.orcarouter.ai' },
-      upstreamHeaders: { authorization: 'Bearer sk-gateway-key' },
-      upstreamHeadersOrigin: 'https://api.orcarouter.ai',
-    });
-    closers.push(proxy.close);
-
-    await post(`${proxy.url}${forwardBasePath(ZEN_GO)}/chat/completions`, {
-      ...TURN,
-      model: 'glm-5.3-flash',
-    });
-
-    expect(up.calls[0]!.url).toBe('https://api.orcarouter.ai/v1/chat/completions');
-    expect(up.calls[0]!.headers['authorization']).toBe('Bearer sk-gateway-key');
-  });
-
-  // `/v1/moderations`, not `/v1/embeddings`, and that is the whole point of these two: an
-  // embeddings path is claimed by a retrieval rule now, so a test written about an *unclaimed*
-  // tail that keeps using one stops asking its own question. The retrieval half is asserted where
-  // it belongs, in `retrieval.test.ts`.
-  it('sends an unclaimed tail through passthrough to the forwarded base, past a configured gateway', async () => {
-    const up = stubUpstream({ object: 'list', data: [] });
-    const seen: NetExchange[] = [];
-    const proxy = await createProxy({
-      mode: 'record',
-      fetchImpl: up.fetchImpl,
-      onNetExchange: (e) => void seen.push(e),
-    });
-    closers.push(proxy.close);
-
-    const res = await post(`${proxy.url}${forwardBasePath(ZEN_GO)}/v1/moderations`, {
-      input: 'hello',
-    });
-
-    expect(res.status).toBe(200);
-    expect(up.calls[0]!.url).toBe(`${ZEN_GO}/v1/moderations`);
-    expect(seen[0]).toMatchObject({ host: 'opencode.ai', path: '/v1/moderations', status: 200 });
-    expect(proxy.stats().passedThrough).toBe(1);
-  });
-
-  it('lets a configured gateway have an unclaimed tail on a fork, where the fork decides', async () => {
-    // Substituting the model is the operator choosing where answers come from, so the fork's
-    // configured origin decides for an unclaimed tail too. A retrieval call is the exception, and
-    // it is one for a reason that does not apply here: agenticreplay knows what it is and forwards it
-    // unchanged, so the destination it announces is the only one anything can say about it.
-    const up = stubUpstream({ object: 'list', data: [] });
-    const proxy = await createProxy({
-      mode: 'hybrid',
-      exchanges: [],
-      forkAt: 0,
-      forkModel: 'gpt-5.6-luna',
-      fetchImpl: up.fetchImpl,
-      upstream: { openai: 'https://api.orcarouter.ai' },
-    });
-    closers.push(proxy.close);
-
-    await post(`${proxy.url}${forwardBasePath(ZEN_GO)}/v1/moderations`, { input: 'hello' });
-
-    expect(up.calls[0]!.url).toBe('https://api.orcarouter.ai/v1/moderations');
-  });
-
-  it('treats an undecodable /forward/ path as an ordinary unclaimed path', async () => {
-    const up = stubUpstream({ ok: true });
-    const proxy = await createProxy({
-      mode: 'record',
-      fetchImpl: up.fetchImpl,
-      passthroughUpstream: 'https://api.openai.com',
-    });
-    closers.push(proxy.close);
-
-    const res = await post(`${proxy.url}/forward/plain`, { input: 'x' });
-
-    expect(res.status).toBe(200);
-    expect(up.calls[0]!.url).toBe('https://api.openai.com/forward/plain');
-  });
-
-  it('answers 404 to a GET on a forwarded path, as to any other', async () => {
-    const up = stubUpstream({ ok: true });
-    const proxy = await createProxy({ mode: 'record', fetchImpl: up.fetchImpl });
-    closers.push(proxy.close);
-
-    const res = await fetch(`${proxy.url}${forwardBasePath(ZEN_GO)}/chat/completions`);
-    expect(res.status).toBe(404);
-    expect(await res.text()).toContain('GET');
-    expect(up.calls).toHaveLength(0);
-  });
-});
-
-describe('a cross-provider fork drops the forwarded base', () => {
-  it('serves the fork target from its own origin, not the recorded one', async () => {
-    // Forking an OpenAI-compatible recording onto a Claude model means the answer comes from
-    // api.anthropic.com; the forwarded base pointed at the recorded provider and is incoherent
-    // for the translation. The explicit upstream or the target default decides instead.
-    const up = stubUpstream({
-      id: 'm1',
-      content: [],
-      usage: { input_tokens: 1, output_tokens: 1 },
-    });
-    const proxy = await createProxy({
-      mode: 'hybrid',
-      exchanges: [],
-      forkAt: 0,
-      forkModel: 'claude-opus-5',
-      fetchImpl: up.fetchImpl,
-    });
-    closers.push(proxy.close);
-
-    await post(`${proxy.url}${forwardBasePath(ZEN_GO)}/chat/completions`, TURN);
-
-    expect(up.calls[0]!.url).toBe('https://api.anthropic.com/v1/messages');
-  });
-});
-
-describe('replay — a forwarded path is matched, not forwarded', () => {
-  it('serves a matching exchange from the recording', async () => {
-    // Recorded through the same forward path, so the fixture is an exchange the proxy itself
-    // built — the matcher compares canonical forms, and a hand-written one is a test of the
-    // author's memory of the translator.
-    const reply = { id: 'c1', choices: [{ message: { role: 'assistant', content: 'recorded' } }] };
-    const recorder = stubUpstream(reply);
-    const record = await createProxy({ mode: 'record', fetchImpl: recorder.fetchImpl });
-    closers.push(record.close);
-    await post(`${record.url}${forwardBasePath(ZEN_GO)}/chat/completions`, TURN);
-
-    const up = stubUpstream({ id: 'live', choices: [] });
-    const proxy = await createProxy({
-      mode: 'replay',
-      exchanges: record.exchanges(),
-      fetchImpl: up.fetchImpl,
-    });
-    closers.push(proxy.close);
-
-    const res = await post(`${proxy.url}${forwardBasePath(ZEN_GO)}/chat/completions`, TURN);
-
-    expect(res.status).toBe(200);
-    expect(JSON.parse(res.text).choices[0].message.content).toBe('recorded');
-    expect(up.calls).toHaveLength(0);
-    expect(proxy.stats().matchedExact).toBe(1);
-  });
-});

package/packages/proxy/test/hop-by-hop.test.ts

@@ -1,118 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import { createProxy } from '../src/server.js';
-
-const closers: Array<() => Promise<void>> = [];
-afterEach(async () => {
-  while (closers.length) await closers.pop()!();
-});
-
-/**
- * Headers that describe *this* connection and must not be relayed onto the next one.
- *
- * The list held four names and was missing `transfer-encoding`, which is the one that actually
- * bites. An SDK that hands `fetch` a `Request` rather than a URL string sends its body chunked —
- * the Vercel AI SDK and every wrapper like it do — and the proxy copied `transfer-encoding:
- * chunked` onto an outbound call that had already buffered the body. undici rejects that, so the
- * agent got `500 {"error":{"message":"TypeError: fetch failed"}}` on any turn with a streamed
- * body. Nothing in the message points at a header, or at agenticreplay, or at the agent.
- */
-const BODY = {
-  model: 'gpt-5.2',
-  input: [{ role: 'user', content: [{ type: 'input_text', text: 'hello' }] }],
-};
-
-const REPLY = {
-  id: 'resp_1',
-  object: 'response',
-  status: 'completed',
-  model: 'gpt-5.2',
-  output: [
-    { type: 'message', id: 'm', role: 'assistant', content: [{ type: 'output_text', text: 'hi' }] },
-  ],
-  usage: { input_tokens: 1, output_tokens: 1 },
-};
-
-function stubUpstream() {
-  const calls: { headers: Record<string, string>; body: string }[] = [];
-  const fetchImpl = (async (_url: string, init: RequestInit = {}) => {
-    const headers: Record<string, string> = {};
-    for (const [k, v] of Object.entries((init.headers ?? {}) as Record<string, string>)) {
-      headers[k.toLowerCase()] = v;
-    }
-    calls.push({ headers, body: String(init.body ?? '') });
-    return new Response(JSON.stringify(REPLY), {
-      status: 200,
-      headers: { 'content-type': 'application/json' },
-    });
-  }) as unknown as typeof fetch;
-  return { calls, fetchImpl };
-}
-
-describe('a request whose body arrives chunked', () => {
-  /**
-   * A stream body, which is what makes Node send `transfer-encoding: chunked` and no
-   * `content-length`. An SDK reaches this shape by handing `fetch` a `Request` built from another
-   * `Request` — which is exactly what the instrument hook does when it rewrites one.
-   */
-  const chunked = (url: string) =>
-    fetch(url, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json', 'x-keep-me': 'yes' },
-      body: new ReadableStream({
-        start(controller) {
-          controller.enqueue(new TextEncoder().encode(JSON.stringify(BODY)));
-          controller.close();
-        },
-      }),
-      // Required by Node whenever a body is a stream.
-      duplex: 'half',
-    } as RequestInit & { duplex: 'half' });
-
-  it('is answered, not turned into a 500', async () => {
-    const up = stubUpstream();
-    const proxy = await createProxy({ mode: 'record', fetchImpl: up.fetchImpl });
-    closers.push(proxy.close);
-
-    const res = await chunked(`${proxy.url}/v1/responses`);
-
-    expect(res.status).toBe(200);
-    expect(await res.json()).toEqual(REPLY);
-  });
-
-  it('does not relay transfer-encoding onto a call that already has the whole body', async () => {
-    const up = stubUpstream();
-    const proxy = await createProxy({ mode: 'record', fetchImpl: up.fetchImpl });
-    closers.push(proxy.close);
-
-    await chunked(`${proxy.url}/v1/responses`);
-
-    expect(up.calls).toHaveLength(1);
-    for (const name of ['transfer-encoding', 'connection', 'host', 'content-length']) {
-      expect(up.calls[0]!.headers[name], name).toBeUndefined();
-    }
-    // The body really did arrive, so the header was the only thing dropped.
-    expect(up.calls[0]!.body).toContain('hello');
-  });
-
-  it('keeps the headers that are not about this connection', async () => {
-    const up = stubUpstream();
-    const proxy = await createProxy({ mode: 'record', fetchImpl: up.fetchImpl });
-    closers.push(proxy.close);
-
-    await chunked(`${proxy.url}/v1/responses`);
-
-    expect(up.calls[0]!.headers['x-keep-me']).toBe('yes');
-    expect(up.calls[0]!.headers['content-type']).toContain('application/json');
-  });
-
-  it('records the exchange, so a chunked turn is not silently missing from the trace', async () => {
-    const up = stubUpstream();
-    const proxy = await createProxy({ mode: 'record', fetchImpl: up.fetchImpl });
-    closers.push(proxy.close);
-
-    await chunked(`${proxy.url}/v1/responses`);
-
-    expect(proxy.exchanges()).toHaveLength(1);
-    expect(proxy.exchanges()[0]!.canonicalRequest.model).toBe('gpt-5.2');
-  });
-});

package/packages/proxy/test/image-matching.test.ts

@@ -1,129 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { CanonicalRequest } from '@agenticreplay/plugin-api';
-import { RequestMatcher, canonicalHash, structuralDistance } from '../src/matching.js';
-
-/**
- * A replay cannot re-render a screenshot, so the matcher must not compare one.
- *
- * This is the same argument the salted-placeholder fold already makes, arriving through a
- * different door. AgenticReplay does not intercept the world: replaying a browser agent drives the *real*
- * browser, which paints the page a second time, and two paintings of one page are not the same
- * bytes — a caret blinked, a font landed a frame later, the article was edited between runs.
- *
- * Measured on a browser-use run against Wikipedia, recorded and then replayed:
- *
- *     turn 1   distance 545,134   —   with the pixels set aside: 171
- *
- * The screenshot is 94% of the request body, so no rung-2 budget can absorb it: one generous
- * enough to admit a repainted page would admit a different conversation. Replay of any agent with
- * eyes was therefore impossible by construction, not by bad luck.
- *
- * What makes the fold safe is that the pixels are not what identify the request. browser-use sends
- * the element tree, the page URL and the agent's own memory in the same message, as text, and that
- * text stays fully compared — in the same measurement, the turns where the two runs genuinely took
- * different paths still scored 14,191, 19,409 and 57,519 with the pixels already set aside.
- */
-
-const PNG_A = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQ';
-const PNG_B = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFhgJ/lRGGKQ';
-
-/** A turn shaped like browser-use's: what the page looks like, and what the page *is*. */
-function shot(
-  png: string,
-  page = 'url=https://en.wikipedia.org\n[18]<input search>',
-): CanonicalRequest {
-  return {
-    model: 'gpt-5.6-luna',
-    system: 'You are a browser agent.',
-    messages: [
-      {
-        role: 'user',
-        content: [
-          { type: 'text', text: page },
-          { type: 'image', media_type: 'image/png', data: png },
-        ],
-      },
-    ],
-    max_tokens: 4096,
-  };
-}
-
-describe('image payloads below rung 1', () => {
-  it('does not count a repainted screenshot as distance', () => {
-    expect(structuralDistance(shot(PNG_A), shot(PNG_B))).toBe(0);
-  });
-
-  it('still counts the text that came with it', () => {
-    const moved = shot(
-      PNG_B,
-      'url=https://en.wikipedia.org/wiki/AgenticReplay\n[18]<input search>',
-    );
-    expect(structuralDistance(shot(PNG_A), moved)).toBeGreaterThan(0);
-  });
-
-  it('matches a replayed turn whose only difference is the repaint', () => {
-    const matcher = new RequestMatcher([shot(PNG_A)]);
-    const result = matcher.match(shot(PNG_B));
-    expect(result.matched).toBe(true);
-    expect(result.rung).toBe(2);
-  });
-
-  it('names the images in the divergence, rather than matching quietly', () => {
-    // The spec's rule for the whole ladder: replay never silently approximates. A fold nobody is
-    // told about is exactly that.
-    const matcher = new RequestMatcher([shot(PNG_A)]);
-    const { divergence } = matcher.match(shot(PNG_B));
-    expect(divergence?.level).toBe('minor');
-    expect(divergence?.detail).toContain('1 image');
-    expect(divergence?.detail).toContain('pixels are not compared');
-  });
-
-  it('says "images" for more than one, and does not mention redaction when nothing was redacted', () => {
-    // The bug this pins: the rung-2a sentence used to name only the placeholder fold, so a request
-    // that reached it on the image fold alone read "identical apart from 0 redacted values".
-    const two = (png: string): CanonicalRequest => ({
-      ...shot(png),
-      messages: [
-        { role: 'user', content: [{ type: 'image', media_type: 'image/png', data: png }] },
-        { role: 'assistant', content: [{ type: 'text', text: 'looking' }] },
-        { role: 'user', content: [{ type: 'image', media_type: 'image/png', data: png }] },
-      ],
-    });
-    const { divergence } = new RequestMatcher([two(PNG_A)]).match(two(PNG_B));
-    expect(divergence?.detail).toContain('2 images');
-    expect(divergence?.detail).not.toContain('redacted');
-  });
-
-  it('keeps rung 1 meaning exact — the payload is still in the canonical hash', () => {
-    // The fold is below rung 1 only. A run whose screenshots genuinely came back identical must
-    // still be reported as an exact match, and two different images must not hash alike.
-    expect(canonicalHash(shot(PNG_A))).toBe(canonicalHash(shot(PNG_A)));
-    expect(canonicalHash(shot(PNG_A))).not.toBe(canonicalHash(shot(PNG_B)));
-    expect(new RequestMatcher([shot(PNG_A)]).match(shot(PNG_A)).rung).toBe(1);
-  });
-
-  it('does not let a different page through on the strength of a folded image', () => {
-    // The whole risk of the fold. A screenshot of some other site arrives with the text that
-    // describes that other site, and it is the text that must halt the replay.
-    const elsewhere = shot(PNG_B, 'url=https://example.com/login\n[3]<input password>');
-    const result = new RequestMatcher([shot(PNG_A)]).match(elsewhere);
-    expect(result.matched).toBe(false);
-    expect(result.rung).toBe(4);
-  });
-
-  it('keeps the media type, so a PNG does not match a JPEG', () => {
-    const jpeg: CanonicalRequest = {
-      ...shot(PNG_B),
-      messages: [
-        {
-          role: 'user',
-          content: [
-            { type: 'text', text: 'url=https://en.wikipedia.org\n[18]<input search>' },
-            { type: 'image', media_type: 'image/jpeg', data: PNG_B },
-          ],
-        },
-      ],
-    };
-    expect(structuralDistance(shot(PNG_A), jpeg)).toBeGreaterThan(0);
-  });
-});