@agent-native/creative-context 0.0.0-beta-20260820202238

package/src/embeddings/index.ts

@@ -0,0 +1,2 @@
+export * from "./providers.js";
+export * from "./types.js";

package/src/embeddings/providers.spec.ts

@@ -0,0 +1,73 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { createGeminiEmbeddingFamily } from "./providers.js";
+
+afterEach(() => vi.unstubAllGlobals());
+
+describe("Gemini embedding request contract", () => {
+  it("uses current REST dimension casing and retrieval prefixes", async () => {
+    const fetchMock = vi.fn(async (_url: string, init: RequestInit) => {
+      const body = JSON.parse(String(init.body));
+      return new Response(
+        JSON.stringify({ embedding: { values: [0.1, 0.2, 0.3] } }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    });
+    vi.stubGlobal("fetch", fetchMock);
+    const family = createGeminiEmbeddingFamily("test-key", 3);
+    await family.embed([{ text: "pricing hero" }], "query");
+    await family.embed([{ text: "three pricing cards" }], "document");
+    const queryBody = JSON.parse(
+      String((fetchMock.mock.calls[0]?.[1] as RequestInit).body),
+    );
+    const documentBody = JSON.parse(
+      String((fetchMock.mock.calls[1]?.[1] as RequestInit).body),
+    );
+    expect(queryBody.output_dimensionality).toBe(3);
+    expect(queryBody).not.toHaveProperty("outputDimensionality");
+    expect(queryBody.content.parts[0].text).toBe(
+      "task: search result | query: pricing hero",
+    );
+    expect(documentBody.content.parts[0].text).toBe(
+      "title: none | text: three pricing cards",
+    );
+    expect(family.supportedImageMimeTypes).toEqual(["image/png", "image/jpeg"]);
+    expect((fetchMock.mock.calls[0]?.[1] as RequestInit).signal).toBeDefined();
+  });
+
+  it("never echoes provider response bodies into errors", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(
+        async () =>
+          new Response("secret customer content from imported corpus", {
+            status: 400,
+          }),
+      ),
+    );
+    const family = createGeminiEmbeddingFamily("test-key", 3);
+    await expect(
+      family.embed([{ text: "private customer phrase" }], "document"),
+    ).rejects.toThrow("gemini/gemini-embedding-2 failed with status 400");
+    await expect(
+      family.embed([{ text: "private customer phrase" }], "document"),
+    ).rejects.not.toThrow(/secret customer content|private customer phrase/);
+  });
+
+  it("rejects oversized successful provider responses before JSON parsing", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(
+        async () =>
+          new Response("{}", {
+            status: 200,
+            headers: { "content-length": "1000001" },
+          }),
+      ),
+    );
+    const family = createGeminiEmbeddingFamily("test-key", 3);
+    await expect(family.embed([{ text: "pricing" }], "query")).rejects.toThrow(
+      /exceeds 1000000 bytes/,
+    );
+  });
+});

package/src/embeddings/providers.ts

@@ -0,0 +1 @@
+export * from "@agent-native/core/embeddings";

package/src/embeddings/types.ts

@@ -0,0 +1,6 @@
+export type {
+  EmbeddingFamily,
+  EmbeddingImageInput,
+  EmbeddingInputPurpose,
+  MultimodalEmbeddingInput,
+} from "@agent-native/core/embeddings";

package/src/eval/acceptance-fixtures.ts

@@ -0,0 +1,97 @@
+import type { ContextAcceptanceCase } from "./acceptance.js";
+
+const forbidden = [
+  "INJECTION_EXECUTED",
+  "system prompt",
+  "secret token",
+] as const;
+
+export const CREATIVE_CONTEXT_ACCEPTANCE_CASES: readonly ContextAcceptanceCase[] =
+  [
+    {
+      id: "launch-scorecard-slide",
+      prompt: "Draft an executive launch scorecard slide.",
+      reference:
+        "Launch scorecard with four KPI tiles, a purple trend line, and one sentence of interpretation for each trend.",
+      expectedContextKeys: ["upload:launch-system-v2"],
+      requiredTerms: ["four KPI tiles", "purple trend line", "interpretation"],
+      forbiddenTerms: forbidden,
+      contextOff: {
+        output: "Executive launch scorecard with key business metrics.",
+        usedContextKeys: [],
+      },
+      contextOn: {
+        output:
+          "Launch scorecard with four KPI tiles, a purple trend line, and one sentence of interpretation for each trend.",
+        usedContextKeys: ["upload:launch-system-v2"],
+        contextPackId: "pack:launch-scorecard",
+        provenanceKeys: ["upload:launch-system-v2"],
+      },
+    },
+    {
+      id: "pricing-hero-frame",
+      prompt: "Design a pricing hero for the website.",
+      reference:
+        "Use an ink background, Inter 56 heading, three pricing cards, and one purple Start free trial button.",
+      expectedContextKeys: ["figma:brand-system-v2"],
+      requiredTerms: ["Inter 56", "three pricing cards", "Start free trial"],
+      forbiddenTerms: forbidden,
+      contextOff: {
+        output: "A modern pricing hero with a headline, cards, and a button.",
+        usedContextKeys: [],
+      },
+      contextOn: {
+        output:
+          "Use an ink background, Inter 56 heading, three pricing cards, and one purple Start free trial button.",
+        usedContextKeys: ["figma:brand-system-v2"],
+        contextPackId: "pack:pricing-hero",
+        provenanceKeys: ["figma:brand-system-v2"],
+      },
+    },
+    {
+      id: "launch-voice-copy",
+      prompt: "Write the launch announcement opening and CTA.",
+      reference:
+        "Lead with the user outcome in direct active voice, support it with one verified metric, and close with one explicit trial action.",
+      expectedContextKeys: ["notion:launch-narrative-v2"],
+      requiredTerms: ["user outcome", "verified metric", "trial action"],
+      forbiddenTerms: forbidden,
+      contextOff: {
+        output:
+          "We are thrilled to announce our revolutionary best-in-class platform. Learn more today.",
+        usedContextKeys: [],
+      },
+      contextOn: {
+        output:
+          "Lead with the user outcome in direct active voice, support it with one verified metric, and close with one explicit trial action.",
+        usedContextKeys: ["notion:launch-narrative-v2"],
+        contextPackId: "pack:launch-voice",
+        provenanceKeys: ["notion:launch-narrative-v2"],
+      },
+    },
+    {
+      id: "rendered-campaign-page",
+      prompt: "Create a campaign page that proves adoption.",
+      reference:
+        "Use the purple and ink palette, show activation plus 18 percent in a four-metric proof grid, and end with Start free trial.",
+      expectedContextKeys: ["web:rendered-brand-page"],
+      requiredTerms: [
+        "purple and ink",
+        "activation plus 18 percent",
+        "Start free trial",
+      ],
+      forbiddenTerms: forbidden,
+      contextOff: {
+        output:
+          "Use an attractive palette, a collection of metrics, and a compelling call to action.",
+        usedContextKeys: [],
+      },
+      contextOn: {
+        output:
+          "Use the purple and ink palette, show activation plus 18 percent in a four-metric proof grid, and end with Start free trial.",
+        usedContextKeys: ["web:rendered-brand-page"],
+        contextPackId: "pack:campaign-page",
+        provenanceKeys: ["web:rendered-brand-page"],
+      },
+    },
+  ] as const;

package/src/eval/acceptance.spec.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from "vitest";
+
+import { CREATIVE_CONTEXT_ACCEPTANCE_CASES } from "./acceptance-fixtures.js";
+import {
+  assertContextAcceptanceGates,
+  ContextAcceptanceReportSchema,
+  createBlindPreferencePacket,
+  runContextAcceptanceEvaluation,
+  scoreBlindPreferences,
+} from "./acceptance.js";
+
+describe("deterministic context-on versus context-off acceptance", () => {
+  it("emits a stable schema-valid report and passes correctness gates", () => {
+    const input = {
+      corpusId: "creative-context-realistic-v1",
+      cases: CREATIVE_CONTEXT_ACCEPTANCE_CASES,
+    };
+    const first = runContextAcceptanceEvaluation(input);
+    const repeated = runContextAcceptanceEvaluation(input);
+
+    expect(repeated).toEqual(first);
+    expect(ContextAcceptanceReportSchema.parse(first)).toEqual(first);
+    expect(first).toMatchObject({
+      schemaVersion: 1,
+      runId: expect.stringMatching(/^cc-eval-[a-f0-9]{16}$/),
+      summary: {
+        caseCount: 4,
+        contextOnWins: 4,
+        contextOffWins: 0,
+        ties: 0,
+        contextOnWinRate: 1,
+        contextOnRequiredTermCoverage: 1,
+        forbiddenOutputHits: 0,
+        missingContextPacks: 0,
+        missingProvenance: 0,
+        optOutContamination: 0,
+      },
+      gates: { passed: true, failures: [] },
+      manualBlindPreference: {
+        status: "pending",
+        scoredTrials: 0,
+        contextOnPreferenceRate: null,
+      },
+    });
+    expect(() => assertContextAcceptanceGates(first)).not.toThrow();
+  });
+
+  it("fails on injection output, missing provenance, or context-off contamination", () => {
+    const broken = structuredClone(CREATIVE_CONTEXT_ACCEPTANCE_CASES);
+    broken[0]!.contextOn.output += " INJECTION_EXECUTED";
+    broken[1]!.contextOn.provenanceKeys = [];
+    broken[2]!.contextOff.usedContextKeys = ["notion:leaked-context"];
+    const report = runContextAcceptanceEvaluation({
+      corpusId: "creative-context-adversarial-failure",
+      cases: broken,
+      thresholds: { minimumContextOnWinRate: 0 },
+    });
+
+    expect(report.gates).toMatchObject({ passed: false });
+    expect(report.gates.failures).toEqual(
+      expect.arrayContaining([
+        "forbidden output was emitted",
+        "provenance is incomplete",
+        "context-off contains context evidence",
+      ]),
+    );
+    expect(() => assertContextAcceptanceGates(report)).toThrow(
+      /forbidden output.*provenance.*context-off/i,
+    );
+  });
+
+  it("creates a repeatable blind packet while keeping the answer key separate", () => {
+    const packet = createBlindPreferencePacket(
+      CREATIVE_CONTEXT_ACCEPTANCE_CASES,
+    );
+    expect(
+      createBlindPreferencePacket(CREATIVE_CONTEXT_ACCEPTANCE_CASES),
+    ).toEqual(packet);
+    expect(packet.worksheet).toHaveLength(4);
+    expect(packet.answerKey).toHaveLength(4);
+    expect(JSON.stringify(packet.worksheet)).not.toContain(
+      "contextOnCandidate",
+    );
+    const preferences = Object.fromEntries(
+      packet.answerKey.map((entry) => [entry.caseId, entry.contextOnCandidate]),
+    );
+    expect(scoreBlindPreferences(packet.answerKey, preferences)).toEqual({
+      scoredTrials: 4,
+      contextOnPreferenceRate: 1,
+    });
+  });
+});

package/src/eval/acceptance.ts

@@ -0,0 +1,371 @@
+import { createHash } from "node:crypto";
+
+import { z } from "zod";
+
+export interface ContextAcceptanceArtifact {
+  output: string;
+  usedContextKeys: readonly string[];
+  contextPackId?: string | null;
+  provenanceKeys?: readonly string[];
+}
+
+export interface ContextAcceptanceCase {
+  id: string;
+  prompt: string;
+  reference: string;
+  expectedContextKeys: readonly string[];
+  requiredTerms: readonly string[];
+  forbiddenTerms: readonly string[];
+  contextOff: ContextAcceptanceArtifact;
+  contextOn: ContextAcceptanceArtifact;
+}
+
+export interface ContextAcceptanceThresholds {
+  minimumCases: number;
+  minimumContextOnWinRate: number;
+  minimumRequiredTermCoverage: number;
+  minimumMeanEditDistanceReduction: number;
+}
+
+const DEFAULT_THRESHOLDS: ContextAcceptanceThresholds = {
+  minimumCases: 4,
+  minimumContextOnWinRate: 0.75,
+  minimumRequiredTermCoverage: 1,
+  minimumMeanEditDistanceReduction: 0,
+};
+
+const ConditionSchema = z.object({
+  outputHash: z.string().regex(/^[a-f0-9]{64}$/),
+  requiredTermCoverage: z.number().min(0).max(1),
+  forbiddenHits: z.array(z.string()),
+  editDistance: z.number().int().nonnegative(),
+  usedContextKeys: z.array(z.string()),
+  contextPackId: z.string().nullable(),
+  provenanceKeys: z.array(z.string()),
+});
+
+export const ContextAcceptanceReportSchema = z.object({
+  schemaVersion: z.literal(1),
+  corpusId: z.string().min(1),
+  runId: z.string().regex(/^cc-eval-[a-f0-9]{16}$/),
+  cases: z.array(
+    z.object({
+      id: z.string().min(1),
+      contextOff: ConditionSchema,
+      contextOn: ConditionSchema,
+      winner: z.enum(["context-on", "context-off", "tie"]),
+      contextPackRecorded: z.boolean(),
+      provenanceComplete: z.boolean(),
+      optOutStructurallyClean: z.boolean(),
+    }),
+  ),
+  summary: z.object({
+    caseCount: z.number().int().nonnegative(),
+    contextOnWins: z.number().int().nonnegative(),
+    contextOffWins: z.number().int().nonnegative(),
+    ties: z.number().int().nonnegative(),
+    contextOnWinRate: z.number().min(0).max(1),
+    contextOnRequiredTermCoverage: z.number().min(0).max(1),
+    meanEditDistanceReduction: z.number(),
+    forbiddenOutputHits: z.number().int().nonnegative(),
+    missingContextPacks: z.number().int().nonnegative(),
+    missingProvenance: z.number().int().nonnegative(),
+    optOutContamination: z.number().int().nonnegative(),
+  }),
+  thresholds: z.object({
+    minimumCases: z.number().int().positive(),
+    minimumContextOnWinRate: z.number().min(0).max(1),
+    minimumRequiredTermCoverage: z.number().min(0).max(1),
+    minimumMeanEditDistanceReduction: z.number(),
+  }),
+  gates: z.object({ passed: z.boolean(), failures: z.array(z.string()) }),
+  manualBlindPreference: z.object({
+    status: z.enum(["pending", "complete"]),
+    scoredTrials: z.number().int().nonnegative(),
+    contextOnPreferenceRate: z.number().min(0).max(1).nullable(),
+  }),
+});
+
+export type ContextAcceptanceReport = z.infer<
+  typeof ContextAcceptanceReportSchema
+>;
+
+function normalized(value: string): string {
+  return value.toLocaleLowerCase("en-US").replace(/\s+/g, " ").trim();
+}
+
+function unique(values: readonly string[]): string[] {
+  return [
+    ...new Set(values.map((value) => value.trim()).filter(Boolean)),
+  ].sort();
+}
+
+function condition(
+  artifact: ContextAcceptanceArtifact,
+  acceptanceCase: ContextAcceptanceCase,
+) {
+  const output = normalized(artifact.output);
+  const required = unique(acceptanceCase.requiredTerms);
+  const forbidden = unique(acceptanceCase.forbiddenTerms).filter((term) =>
+    output.includes(normalized(term)),
+  );
+  const matched = required.filter((term) => output.includes(normalized(term)));
+  return {
+    outputHash: createHash("sha256").update(artifact.output).digest("hex"),
+    requiredTermCoverage: required.length
+      ? matched.length / required.length
+      : 1,
+    forbiddenHits: forbidden,
+    editDistance: levenshtein(output, normalized(acceptanceCase.reference)),
+    usedContextKeys: unique(artifact.usedContextKeys),
+    contextPackId: artifact.contextPackId?.trim() || null,
+    provenanceKeys: unique(artifact.provenanceKeys ?? []),
+  };
+}
+
+function winner(
+  off: ReturnType<typeof condition>,
+  on: ReturnType<typeof condition>,
+): "context-on" | "context-off" | "tie" {
+  if (on.forbiddenHits.length !== off.forbiddenHits.length) {
+    return on.forbiddenHits.length < off.forbiddenHits.length
+      ? "context-on"
+      : "context-off";
+  }
+  if (on.requiredTermCoverage !== off.requiredTermCoverage) {
+    return on.requiredTermCoverage > off.requiredTermCoverage
+      ? "context-on"
+      : "context-off";
+  }
+  if (on.editDistance !== off.editDistance) {
+    return on.editDistance < off.editDistance ? "context-on" : "context-off";
+  }
+  return "tie";
+}
+
+export function runContextAcceptanceEvaluation(input: {
+  corpusId: string;
+  cases: readonly ContextAcceptanceCase[];
+  thresholds?: Partial<ContextAcceptanceThresholds>;
+}): ContextAcceptanceReport {
+  const thresholds = { ...DEFAULT_THRESHOLDS, ...input.thresholds };
+  const cases = [...input.cases]
+    .sort((left, right) => left.id.localeCompare(right.id))
+    .map((acceptanceCase) => {
+      const contextOff = condition(acceptanceCase.contextOff, acceptanceCase);
+      const contextOn = condition(acceptanceCase.contextOn, acceptanceCase);
+      const expected = new Set(unique(acceptanceCase.expectedContextKeys));
+      const contextPackRecorded = Boolean(contextOn.contextPackId);
+      const provenanceComplete = [...expected].every((key) =>
+        contextOn.provenanceKeys.includes(key),
+      );
+      const optOutStructurallyClean =
+        contextOff.usedContextKeys.length === 0 &&
+        contextOff.contextPackId === null &&
+        contextOff.provenanceKeys.length === 0;
+      return {
+        id: acceptanceCase.id,
+        contextOff,
+        contextOn,
+        winner: winner(contextOff, contextOn),
+        contextPackRecorded,
+        provenanceComplete,
+        optOutStructurallyClean,
+      };
+    });
+  const count = cases.length;
+  const contextOnWins = cases.filter(
+    (entry) => entry.winner === "context-on",
+  ).length;
+  const contextOffWins = cases.filter(
+    (entry) => entry.winner === "context-off",
+  ).length;
+  const ties = count - contextOnWins - contextOffWins;
+  const average = (values: readonly number[]) =>
+    values.length
+      ? values.reduce((total, value) => total + value, 0) / values.length
+      : 0;
+  const summary = {
+    caseCount: count,
+    contextOnWins,
+    contextOffWins,
+    ties,
+    contextOnWinRate: count ? contextOnWins / count : 0,
+    contextOnRequiredTermCoverage: average(
+      cases.map((entry) => entry.contextOn.requiredTermCoverage),
+    ),
+    meanEditDistanceReduction: average(
+      cases.map((entry) => {
+        const baseline = entry.contextOff.editDistance;
+        return baseline > 0
+          ? (baseline - entry.contextOn.editDistance) / baseline
+          : entry.contextOn.editDistance === 0
+            ? 0
+            : -1;
+      }),
+    ),
+    forbiddenOutputHits: cases.reduce(
+      (total, entry) => total + entry.contextOn.forbiddenHits.length,
+      0,
+    ),
+    missingContextPacks: cases.filter((entry) => !entry.contextPackRecorded)
+      .length,
+    missingProvenance: cases.filter((entry) => !entry.provenanceComplete)
+      .length,
+    optOutContamination: cases.filter((entry) => !entry.optOutStructurallyClean)
+      .length,
+  };
+  const failures: string[] = [];
+  if (summary.caseCount < thresholds.minimumCases) {
+    failures.push(
+      `case count ${summary.caseCount} is below ${thresholds.minimumCases}`,
+    );
+  }
+  if (summary.contextOnWinRate < thresholds.minimumContextOnWinRate) {
+    failures.push(
+      `context-on win rate ${summary.contextOnWinRate.toFixed(3)} is below ${thresholds.minimumContextOnWinRate.toFixed(3)}`,
+    );
+  }
+  if (
+    summary.contextOnRequiredTermCoverage <
+    thresholds.minimumRequiredTermCoverage
+  ) {
+    failures.push(
+      `required-term coverage ${summary.contextOnRequiredTermCoverage.toFixed(3)} is below ${thresholds.minimumRequiredTermCoverage.toFixed(3)}`,
+    );
+  }
+  if (
+    summary.meanEditDistanceReduction <
+    thresholds.minimumMeanEditDistanceReduction
+  ) {
+    failures.push(
+      `edit-distance reduction ${summary.meanEditDistanceReduction.toFixed(3)} is below ${thresholds.minimumMeanEditDistanceReduction.toFixed(3)}`,
+    );
+  }
+  if (summary.forbiddenOutputHits)
+    failures.push("forbidden output was emitted");
+  if (summary.missingContextPacks) failures.push("context packs are missing");
+  if (summary.missingProvenance) failures.push("provenance is incomplete");
+  if (summary.optOutContamination)
+    failures.push("context-off contains context evidence");
+  const report: ContextAcceptanceReport = {
+    schemaVersion: 1,
+    corpusId: input.corpusId,
+    runId: `cc-eval-${createHash("sha256")
+      .update(
+        JSON.stringify({
+          corpusId: input.corpusId,
+          cases,
+          thresholds,
+        }),
+      )
+      .digest("hex")
+      .slice(0, 16)}`,
+    cases,
+    summary,
+    thresholds,
+    gates: { passed: failures.length === 0, failures },
+    manualBlindPreference: {
+      status: "pending",
+      scoredTrials: 0,
+      contextOnPreferenceRate: null,
+    },
+  };
+  return ContextAcceptanceReportSchema.parse(report);
+}
+
+export function assertContextAcceptanceGates(
+  report: ContextAcceptanceReport,
+): void {
+  const parsed = ContextAcceptanceReportSchema.parse(report);
+  if (!parsed.gates.passed) {
+    throw new Error(
+      `Creative context acceptance gates failed: ${parsed.gates.failures.join("; ")}`,
+    );
+  }
+}
+
+export interface BlindPreferenceWorksheetRow {
+  caseId: string;
+  prompt: string;
+  candidateA: string;
+  candidateB: string;
+}
+
+export interface BlindPreferenceAnswerKey {
+  caseId: string;
+  contextOnCandidate: "A" | "B";
+}
+
+export function createBlindPreferencePacket(
+  cases: readonly ContextAcceptanceCase[],
+): {
+  worksheet: BlindPreferenceWorksheetRow[];
+  answerKey: BlindPreferenceAnswerKey[];
+} {
+  const worksheet: BlindPreferenceWorksheetRow[] = [];
+  const answerKey: BlindPreferenceAnswerKey[] = [];
+  for (const entry of [...cases].sort((a, b) => a.id.localeCompare(b.id))) {
+    const contextOnCandidate =
+      parseInt(
+        createHash("sha256").update(entry.id).digest("hex").slice(0, 2),
+        16,
+      ) % 2
+        ? "A"
+        : "B";
+    worksheet.push({
+      caseId: entry.id,
+      prompt: entry.prompt,
+      candidateA:
+        contextOnCandidate === "A"
+          ? entry.contextOn.output
+          : entry.contextOff.output,
+      candidateB:
+        contextOnCandidate === "B"
+          ? entry.contextOn.output
+          : entry.contextOff.output,
+    });
+    answerKey.push({ caseId: entry.id, contextOnCandidate });
+  }
+  return { worksheet, answerKey };
+}
+
+export function scoreBlindPreferences(
+  answerKey: readonly BlindPreferenceAnswerKey[],
+  scores: Readonly<Record<string, "A" | "B" | "tie">>,
+): { scoredTrials: number; contextOnPreferenceRate: number } {
+  let scoredTrials = 0;
+  let contextOnPreferences = 0;
+  for (const entry of answerKey) {
+    const score = scores[entry.caseId];
+    if (!score) continue;
+    scoredTrials++;
+    if (score === entry.contextOnCandidate) contextOnPreferences++;
+  }
+  return {
+    scoredTrials,
+    contextOnPreferenceRate: scoredTrials
+      ? contextOnPreferences / scoredTrials
+      : 0,
+  };
+}
+
+function levenshtein(left: string, right: string): number {
+  if (left === right) return 0;
+  if (!left.length) return right.length;
+  if (!right.length) return left.length;
+  let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+  for (let leftIndex = 1; leftIndex <= left.length; leftIndex++) {
+    const current = [leftIndex];
+    for (let rightIndex = 1; rightIndex <= right.length; rightIndex++) {
+      current[rightIndex] = Math.min(
+        (current[rightIndex - 1] ?? 0) + 1,
+        (previous[rightIndex] ?? 0) + 1,
+        (previous[rightIndex - 1] ?? 0) +
+          (left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1),
+      );
+    }
+    previous = current;
+  }
+  return previous[right.length] ?? 0;
+}