@agentswf/engine 0.1.0-beta.1 → 0.1.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentswf/engine",
-  "version": "0.1.0-beta.1",
+  "version": "0.1.0-beta.3",
   "description": "agents.wf: the engine that runs workflows made of coding agents",
   "license": "MIT",
   "homepage": "https://github.com/romanlv/agentswf",
@@ -29,10 +29,10 @@
     "!src/**/fixtures"
   ],
   "dependencies": {
-    "@agentswf/wf": "0.1.0-beta.0",
-    "@agentswf/contract": "0.1.0-beta.0",
-    "@agentswf/harness": "0.1.0-beta.0",
-    "@agentswf/sandbox": "0.1.0-beta.0",
+    "@agentswf/wf": "0.1.0-beta.3",
+    "@agentswf/contract": "0.1.0-beta.3",
+    "@agentswf/harness": "0.1.0-beta.3",
+    "@agentswf/sandbox": "0.1.0-beta.3",
     "typebox": "^1.3.34"
   },
   "publishConfig": {

package/src/allowance-command.ts

@@ -1,11 +1,12 @@
-import {
-  ALLOWANCE_VERSION,
-  type AllowanceReport,
-  type AllowanceWindow,
-  type HarnessAllowance,
+import type {
+  AllowanceReport,
+  AllowanceWindow,
+  HarnessAllowance,
 } from "@agentswf/contract/records";
 import { HARNESS_NAMES, type Harness } from "@agentswf/harness";
 import { PLAN_BASIS, planPrice } from "./accounting/plans";
+import { messageOf } from "./errors";
+import type { Out } from "./run-commands";
 
 export const allowanceUsage = [
   "usage: awf allowance [harness...] [--json]",
@@ -17,7 +18,7 @@ export const allowanceUsage = [
   "A plan's monthly price is the vendor's list price as of the table's date, not what was",
   `charged: ${PLAN_BASIS}.`,
   "",
-  `--json prints an ${ALLOWANCE_VERSION} record, the interface for scripts, with the plan as the`,
+  `--json prints one document, the interface for scripts, with the plan as the`,
   "harness names it and no price; what it prints otherwise is for reading. A harness that could",
   "not be read says why. Exits 0 once every harness was asked, 2 on a usage error.",
 ].join("\n");
@@ -37,6 +38,27 @@ export function parseAllowanceCommand(argv: readonly string[]): AllowanceCommand
   return { harnesses: harnesses.length > 0 ? harnesses : [...HARNESS_NAMES], json };
 }
 
+/** `awf allowance`: what is left of each harness's plan, read with `read`. */
+export async function allowanceCommand(
+  argv: readonly string[],
+  io: Out & { read: (harness: Harness) => Promise<HarnessAllowance>; now: () => number },
+): Promise<number> {
+  let command: AllowanceCommand;
+  try {
+    command = parseAllowanceCommand(argv);
+  } catch (error) {
+    io.stderr(`awf: ${messageOf(error)}\n\n${allowanceUsage}`);
+    return 2;
+  }
+  if (command === "help") {
+    io.stdout(allowanceUsage);
+    return 0;
+  }
+  const report = await readReport(command.harnesses, io.read, io.now());
+  io.stdout(command.json ? JSON.stringify(report, null, 2) : describeReport(report));
+  return 0;
+}
+
 /** Every harness asked at once: cursor's pane takes seconds the others need not wait for. */
 export async function readReport(
   harnesses: readonly Harness[],
@@ -44,7 +66,7 @@ export async function readReport(
   now: number,
 ): Promise<AllowanceReport> {
   return {
-    version: ALLOWANCE_VERSION,
+    v: 1,
     readAt: new Date(now).toISOString(),
     harnesses: await Promise.all(harnesses.map(read)),
   };

package/src/attempt-ending.ts

@@ -12,6 +12,7 @@ import {
 import { PUBLISHED_PRICES } from "./accounting/prices";
 import { summarizeRun } from "./accounting/summary";
 import { messageOf } from "./errors";
+import { RunParked } from "./mailbox";
 import type { Paint } from "./progress-view";
 import { FromStageUnreached, primaryFailure, WorkflowStopped } from "./stopped";
 import {
@@ -53,6 +54,7 @@ export const OUTCOMES: Record<
   { word: string; told: string; mark: (paint: Paint) => string; exitCode?: number }
 > = {
   completed: { word: "completed", told: "completed", mark: (p) => p.ok("✓"), exitCode: 0 },
+  parked: { word: "parked", told: "parked", mark: (p) => p.ok("◇"), exitCode: 0 },
   stopped: { word: "stopped", told: "stopped", mark: (p) => p.busy("■"), exitCode: 3 },
   cancelled: { word: "cancelled", told: "was cancelled", mark: (p) => p.busy("■") },
   "timed-out": { word: "timed out", told: "timed out", mark: (p) => p.bad("✗"), exitCode: 1 },
@@ -63,7 +65,11 @@ export const OUTCOMES: Record<
 export type GoOn = (stop: WorkflowStopped | undefined, entered: readonly StageSummary[]) => string;
 
 /** The ending of a run that returned or threw. */
-export function decideEnding(run: Finished, deadline: AbsoluteDeadline, goOn: GoOn): AttemptEnd {
+export function decideEnding(
+  run: Finished,
+  deadline: AbsoluteDeadline | undefined,
+  goOn: GoOn,
+): AttemptEnd {
   if ("result" in run) {
     const { result } = run;
     return {
@@ -74,6 +80,18 @@ export function decideEnding(run: Finished, deadline: AbsoluteDeadline, goOn: Go
   }
   const { error } = run;
   const settled = error instanceof WorkflowRunError ? error : undefined;
+  const parked = primaryFailure(unwrapped(error));
+  if (parked instanceof RunParked) {
+    return {
+      ending: {
+        kind: "parked",
+        stages: settled?.stages ?? [],
+        ...parked.wait,
+      },
+      ...(settled ? { settled } : {}),
+      exitCode: OUTCOMES.parked.exitCode!,
+    };
+  }
   const { kind, stop, cancellation } = runOutcome(error, deadline);
   const cause = unwrapped(error);
   const beside =
@@ -104,10 +122,10 @@ export function decideEnding(run: Finished, deadline: AbsoluteDeadline, goOn: Go
  */
 export function endedBeforeStart(
   error: unknown,
-  deadline: AbsoluteDeadline,
+  deadline: AbsoluteDeadline | undefined,
   run: { runId: string; startedAt: number; endedAt: number },
   goOn: GoOn,
-): AttemptEnd & { ending: Exclude<Ending<JsonValue>, { kind: "completed" }> } {
+): AttemptEnd & { ending: Exclude<Ending<JsonValue>, { kind: "completed" | "parked" }> } {
   const { kind, cancellation } = runOutcome(error, deadline);
   const times = {
     startedAt: new Date(run.startedAt).toISOString(),
@@ -156,14 +174,14 @@ export function cleanupFailed(end: AttemptEnd, error: unknown, goOn: string): At
  */
 export function runOutcome(
   error: unknown,
-  deadline: AbsoluteDeadline,
+  deadline: AbsoluteDeadline | undefined,
 ): { kind: UnfinishedOutcome; stop?: WorkflowStopped; cancellation?: WorkflowCancelledError } {
   const cancellation = findCancellation(error);
   const failure = primaryFailure(unwrapped(error));
   const stop = failure instanceof WorkflowStopped ? failure : undefined;
   const timedOut =
     failure instanceof DeadlineExceededError &&
-    failure.deadline.unixMilliseconds === deadline.unixMilliseconds;
+    failure.deadline.unixMilliseconds === deadline?.unixMilliseconds;
   const kind = cancellation ? "cancelled" : stop ? "stopped" : timedOut ? "timed-out" : "failed";
   return { kind, ...(stop ? { stop } : {}), ...(cancellation ? { cancellation } : {}) };
 }

package/src/attempt-output.ts

@@ -4,13 +4,15 @@ import {
   type OutputRecord,
   RUN_EVENT_VERSIONS,
 } from "@agentswf/contract/records";
-import type { Ending, ExecutableWorkflow, JsonValue } from "@agentswf/contract/workflow";
+import type { Ending, JsonValue } from "@agentswf/contract/workflow";
 import { attemptAccounting } from "./accounting/summary";
 import type { AttemptEnd } from "./attempt-ending";
 import { messageOf } from "./errors";
 import { writeJson, writeWhole } from "./files";
+import { foldMailbox, readMailbox } from "./mailbox";
 import { type Attempt, appendEvent, endAttempt, outputFile, reportFile } from "./runs";
 import { withoutValue } from "./stage-ledger";
+import type { AnyWorkflow, LoadedWorkflow } from "./workflow-loader";
 
 /** Where an attempt's records went, and its output record as `--json` prints it. */
 export type Kept = {
@@ -30,27 +32,34 @@ export async function keepRecords(
   end: AttemptEnd,
   context: {
     attempt: Attempt;
-    executable: ExecutableWorkflow<JsonValue, JsonValue>;
-    workflow: { name: string; file: string };
+    loaded: LoadedWorkflow;
     stderr: (text: string) => void;
+    /** An event run's: runs `work` holding its run's lock. */
+    locked?: (work: () => Promise<void>) => Promise<void>;
   },
 ): Promise<Kept> {
   const { attempt, stderr } = context;
   const { ending, settled } = end;
   const dir = attempt.run.dir;
-  const report = await writeReport(context.executable, ending, dir, stderr);
+  const report = await writeReport(context.loaded.workflow, ending, dir, stderr);
   const stages = settled?.stages?.map(withoutValue);
-  const at =
-    ending.kind !== "completed" && ending.stage !== undefined ? { stage: ending.stage } : {};
+  const unfinished = ending.kind !== "completed" && ending.kind !== "parked" ? ending : undefined;
+  const at = unfinished?.stage !== undefined ? { stage: unfinished.stage } : {};
   const ended =
     ending.kind === "completed"
       ? { outcome: "completed" as const, value: ending.value }
-      : {
-          outcome: ending.kind,
-          reason: ending.reason,
-          ...at,
-          ...(end.needs ? { needs: [...end.needs] } : {}),
-        };
+      : ending.kind === "parked"
+        ? {
+            outcome: "parked" as const,
+            ...(ending.label === undefined ? {} : { label: ending.label }),
+            ...(ending.until === undefined ? {} : { until: ending.until }),
+          }
+        : {
+            outcome: ending.kind,
+            reason: ending.reason,
+            ...at,
+            ...(end.needs ? { needs: [...end.needs] } : {}),
+          };
   const kept: Kept = report ? { report } : {};
   const output = outputFile(dir);
   if (!settled) {
@@ -63,7 +72,7 @@ export async function keepRecords(
       version: OUTPUT_RECORD_VERSION,
       runId: settled.runId,
       attempt: attempt.record.attempt,
-      workflow: context.workflow,
+      workflow: { name: context.loaded.workflow.meta.name, file: context.loaded.file },
       accounting: settled.accounting,
       usage: settled.usage,
       artifacts: dir,
@@ -91,14 +100,35 @@ export async function keepRecords(
     kind: "attempt-ended",
     outcome: ending.kind,
   }).catch((error) => stderr(`awf: the run's event log was not written: ${messageOf(error)}`));
-  try {
+  // An event run's ending is written holding its run's lock, as parking's is: a sender after it sees
+  // the run returned and is refused, so what no wait took is counted whole. Its last batch was
+  // handled, as the code returned after it.
+  const writeEnding = async () => {
+    const unacknowledged =
+      ending.kind === "completed" && attempt.run.record.events
+        ? await readMailbox(dir).then(
+            // The event that started the run is `workflow.started`'s, taken or not.
+            (records) => {
+              const state = foldMailbox(records);
+              return state.unacknowledged.filter((id) => id !== state.started?.id).length;
+            },
+            (error: unknown) => {
+              stderr(`awf: what no wait took was not counted: ${messageOf(error)}`);
+              return undefined;
+            },
+          )
+        : undefined;
     await endAttempt(attempt, {
       outcome: ending.kind,
-      ...(ending.kind === "completed" ? {} : { reason: ending.reason }),
+      ...(unacknowledged === undefined ? {} : { unacknowledged }),
+      ...(unfinished ? { reason: unfinished.reason } : {}),
       ...at,
       ...(stages ? { stages } : {}),
       ...(settled ? { accounting: attemptAccounting(settled.accounting) } : {}),
     });
+  };
+  try {
+    await (context.locked ?? ((work: () => Promise<void>) => work()))(writeEnding);
   } catch (error) {
     stderr(`awf: the attempt's ending was not written to ${attempt.file}: ${messageOf(error)}`);
   }
@@ -106,7 +136,7 @@ export async function keepRecords(
 }
 
 async function writeReport(
-  executable: ExecutableWorkflow<JsonValue, JsonValue>,
+  workflow: AnyWorkflow,
   ending: Ending<JsonValue>,
   dir: string,
   stderr: (text: string) => void,
@@ -114,11 +144,11 @@ async function writeReport(
   const file = reportFile(dir);
   // An earlier attempt's report is gone with it: report.md is the last ended attempt's.
   const none = () => rm(file, { force: true }).then(() => undefined);
-  if (!executable.report) return none();
+  if (!workflow.report) return none();
   // The result is still in output.json; a report that cannot be rendered or saved should not fail
   // the run, nor cost it its record.
   try {
-    const markdown = executable.report(
+    const markdown = workflow.report(
       ending.kind === "completed" ? ending.value : undefined,
       ending,
     );

package/src/attempt-view.ts

@@ -5,12 +5,7 @@ import type {
   StageNeed,
   StageRecord,
 } from "@agentswf/contract/records";
-import type {
-  Ending,
-  ExecutableWorkflow,
-  JsonValue,
-  StageSummary,
-} from "@agentswf/contract/workflow";
+import type { Ending, JsonValue, StageSummary } from "@agentswf/contract/workflow";
 import { ago, describeAccounting, describeAttempts } from "./accounting/format";
 import { sumAttempts } from "./accounting/summary";
 import { type AttemptEnd, OUTCOMES } from "./attempt-ending";
@@ -22,6 +17,7 @@ import type { RunCommand } from "./run-command";
 import type { AttemptRefusal } from "./runs";
 import { schemaLines } from "./stage-schema";
 import { FromStageUnreached, type WorkflowStopped } from "./stopped";
+import type { AnyWorkflow } from "./workflow-loader";
 
 /**
  * Prints how the attempt ended, and returns its exit code. A completed one's result goes to stdout;
@@ -32,7 +28,7 @@ export function printEnding(
   end: AttemptEnd,
   kept: Kept,
   context: {
-    executable: ExecutableWorkflow<JsonValue, JsonValue>;
+    workflow: AnyWorkflow;
     /** The run's id and folder. */
     run: { id: string; dir: string };
     n: number;
@@ -56,7 +52,7 @@ export function printEnding(
   const { ending, settled } = end;
   const presented =
     ending.kind === "completed" && !context.json
-      ? present(context.executable, ending, stderr)
+      ? present(context.workflow, ending, stderr)
       : undefined;
   if (end.alsoFailed) stderr(`awf: also failed: ${end.alsoFailed}`);
   const again =
@@ -67,7 +63,7 @@ export function printEnding(
   if (context.cleanupAlso) stderr(`awf: runtime cleanup also failed: ${context.cleanupAlso}`);
   // Beside the result rather than in it: stdout stays the workflow's report or the JSON.
   const lines = describeEnding(ending, {
-    named: `${context.executable.definition.meta.name} ${context.run.id}`,
+    named: `${context.workflow.meta.name} ${context.run.id}`,
     n: context.n,
     ...(settled ? { accounting: settled.accounting } : {}),
     earlier: context.earlier,
@@ -78,7 +74,7 @@ export function printEnding(
     ...(end.needs ? { needs: end.needs } : {}),
     ...(settled?.panes ? { panes: settled.panes } : {}),
     // As the run's Herdr workspace is labelled.
-    runWorkspace: `awf ${context.executable.definition.meta.name} ${context.run.id} #${context.n}`,
+    runWorkspace: `awf ${context.workflow.meta.name} ${context.run.id} #${context.n}`,
     paint: context.terminal?.color ? ANSI : PLAIN,
   });
   for (const line of ["", ...lines]) stderr(line);
@@ -91,7 +87,9 @@ export function printEnding(
 export function toldOf(end: AttemptEnd, kept: Kept): string {
   const { ending } = end;
   const told = `${OUTCOMES[ending.kind].told}${kept.output ? `; its record is ${kept.output}` : ""}`;
-  return ending.kind === "completed" ? told : `${told}: ${ending.reason}`;
+  if (ending.kind === "completed") return told;
+  if (ending.kind === "parked") return ending.label ? `${told}: ${ending.label}` : told;
+  return `${told}: ${ending.reason}`;
 }
 
 /**
@@ -135,6 +133,17 @@ function describeEnding(
   if (ending.kind === "completed") {
     return [`${mark} ${word} · ${run}`, ...figures, ...rows([], context)];
   }
+  if (ending.kind === "parked") {
+    const waits = [ending.label, ending.until && `until ${ending.until}`]
+      .filter(Boolean)
+      .join(" · ");
+    return [
+      `${mark} ${word}${waits ? `: ${waits}` : ""}`,
+      `  ${run}`,
+      ...figures,
+      ...rows([], context),
+    ];
+  }
   // A reason's later lines, such as a schema's problems, sit under it, apart from the rows.
   const [first, ...more] = ending.reason.split("\n");
   const goOn = context.choose
@@ -233,13 +242,13 @@ function runTotal(n: number, current: RunAccounting, earlier: readonly AttemptRe
 
 /** A completed attempt's value as the workflow presents it; undefined to print the JSON. */
 function present(
-  executable: ExecutableWorkflow<JsonValue, JsonValue>,
+  workflow: AnyWorkflow,
   ending: Extract<Ending<JsonValue>, { kind: "completed" }>,
   stderr: (text: string) => void,
 ): string | undefined {
-  if (!executable.present) return undefined;
+  if (!workflow.present) return undefined;
   try {
-    return executable.present(ending.value, ending)?.trimEnd();
+    return workflow.present(ending.value, ending)?.trimEnd();
   } catch (error) {
     stderr(`awf: present: ${messageOf(error)}; printing the full result instead`);
     return undefined;
@@ -343,8 +352,9 @@ export function continueCommand(
     ...(command.runRootGiven ? ["--run-root", command.runRoot] : []),
     ...(command.cwdGiven ? ["--cwd", command.cwd] : []),
     pathFrom(command.shellCwd, command.workflowFile),
-    "--continue",
+    "--id",
     id,
+    "--continue",
     ...(redo === undefined ? [] : ["--from-stage", redo]),
     ...(values === undefined ? [] : ["--values", values]),
   ]

package/src/commands.ts

@@ -0,0 +1,176 @@
+import { allowanceUsage } from "./allowance-command";
+import { emitUsage } from "./emit-command";
+import { replyUsage } from "./holder-command";
+import { inboxUsage } from "./inbox-command";
+import { initUsage } from "./init-command";
+import { logsUsage } from "./logs-command";
+import { usage as runUsage } from "./run-command";
+import { shellLine } from "./run-commands";
+import { runsUsage } from "./runs-command";
+import { testUsage } from "./test-command";
+import { tickUsage } from "./tick-command";
+
+/**
+ * Every `awf` command: what the index, `awf help` and the suggestion read, and what the dispatch is
+ * keyed by. An entry's commands share its help; each has its own line in the index.
+ */
+export const COMMANDS = [
+  {
+    group: "Run a workflow",
+    commands: { run: "Start a run of a workflow file, or continue one" },
+    help: runUsage,
+  },
+  { group: "Run a workflow", commands: { test: "Run a workflow's tests" }, help: testUsage },
+  {
+    group: "Run a workflow",
+    commands: { init: "Set up a directory for writing workflows" },
+    help: initUsage,
+  },
+  {
+    group: "Run a workflow",
+    commands: { emit: "Send an event to a workflow with events, starting or waking its run" },
+    help: emitUsage,
+  },
+  {
+    group: "Run a workflow",
+    commands: { tick: "Wake the runs of workflows with events that are due" },
+    help: tickUsage,
+  },
+  {
+    group: "Look at runs",
+    commands: { runs: "The runs here, or one run in depth" },
+    help: runsUsage,
+  },
+  {
+    group: "Look at runs",
+    commands: { logs: "What a run did and is doing, merged by time" },
+    help: logsUsage,
+  },
+  {
+    group: "Coordinate a run from outside",
+    commands: { inbox: "What agents said to a participant outside the run, and what it said back" },
+    help: inboxUsage,
+  },
+  {
+    group: "Coordinate a run from outside",
+    commands: { reply: "Answer a question an agent asked", send: "Message an agent first" },
+    help: replyUsage,
+  },
+  {
+    group: "This machine",
+    commands: { allowance: "What is left of each harness's plan" },
+    help: allowanceUsage,
+  },
+] as const;
+
+type Entry = (typeof COMMANDS)[number];
+type NamesOf<Each> = Each extends { commands: infer Commands } ? keyof Commands & string : never;
+export type CommandName = NamesOf<Entry>;
+
+const NAMES = COMMANDS.flatMap((entry) => Object.keys(entry.commands)) as CommandName[];
+
+export function isCommand(word: string): word is CommandName {
+  return (NAMES as string[]).includes(word);
+}
+
+/** The help `awf help {name}` and `awf {name} -h` print. */
+export function helpOf(name: CommandName): string {
+  return COMMANDS.find((entry) => name in entry.commands)!.help;
+}
+
+const WIDTH = Math.max(...NAMES.map((name) => name.length)) + 2;
+
+function grouped(): [group: string, entries: Entry[]][] {
+  const groups = new Map<string, Entry[]>();
+  for (const entry of COMMANDS)
+    groups.set(entry.group, [...(groups.get(entry.group) ?? []), entry]);
+  return [...groups];
+}
+
+const lines = (entry: Entry) =>
+  Object.entries(entry.commands).map(([name, summary]) => `${name.padEnd(WIDTH)}${summary}`);
+
+/** What `awf`, `awf -h` and `awf help` print. */
+export function index(): string {
+  return [
+    "awf runs workflows of coding agents.",
+    "",
+    "usage: awf <command> [arguments]",
+    "",
+    ...grouped().flatMap(([group, entries]) => [
+      group,
+      ...entries.flatMap(lines).map((line) => `  ${line}`),
+      "",
+    ]),
+    "awf <command> -h      a command's usage, options and exit codes",
+    "awf help reference    every command's usage, on one page",
+    "awf --version",
+  ].join("\n");
+}
+
+/** A command's usage lines: its help up to the first blank line. */
+export function usageLines(help: string): string[] {
+  const end = help.indexOf("\n\n");
+  return (end < 0 ? help : help.slice(0, end)).split("\n");
+}
+
+/** What `awf help reference` prints: each command's summary and usage lines, grouped as the index. */
+export function reference(): string {
+  return [
+    ...grouped().flatMap(([group, entries]) => [
+      group,
+      ...entries.flatMap((entry) => [
+        ...lines(entry).map((line) => `  ${line}`),
+        ...usageLines(entry.help).map((line) => `    ${line}`),
+        "",
+      ]),
+    ]),
+    "awf <command> -h for what each does, and its exit codes",
+  ].join("\n");
+}
+
+const WORKFLOW_FILE = /\.(ts|mts|js|mjs)$/;
+
+/** The one line `awf {word}` gets when no command is named `word`. */
+export function unknownCommand(word: string): string {
+  const said = `awf: no command ${JSON.stringify(word)}`;
+  if (WORKFLOW_FILE.test(word)) return `${said}; did you mean: ${shellLine(["awf", "run", word])}`;
+  const meant = suggest(word);
+  const named =
+    meant.length === 0
+      ? ""
+      : ` did you mean ${meant.length === 1 ? meant[0] : `${meant.slice(0, -1).join(", ")} or ${meant.at(-1)}`}?`;
+  return `${said};${named} awf -h lists the commands`;
+}
+
+/**
+ * The commands `word` is the start of, else the closest within two edits; every one tied for
+ * closest.
+ */
+export function suggest(word: string): CommandName[] {
+  if (word === "") return [];
+  const started = NAMES.filter((name) => name.startsWith(word));
+  if (started.length > 0) return started;
+  const near = NAMES.map((name) => ({ name, distance: distance(word, name) })).filter(
+    (each) => each.distance <= 2,
+  );
+  const closest = Math.min(...near.map((each) => each.distance));
+  return near.filter((each) => each.distance === closest).map((each) => each.name);
+}
+
+/** Levenshtein distance. */
+function distance(a: string, b: string): number {
+  let previous = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i += 1) {
+    const current = [i];
+    for (let j = 1; j <= b.length; j += 1) {
+      current[j] = Math.min(
+        previous[j]! + 1,
+        current[j - 1]! + 1,
+        previous[j - 1]! + (a[i - 1] === b[j - 1] ? 0 : 1),
+      );
+    }
+    previous = current;
+  }
+  return previous[b.length]!;
+}