@loomhelm/multi-task-flow 0.0.0-stage → 0.2.1

package/toolkit/skills/bin/modules/plan/review.ts

@@ -0,0 +1,300 @@
+import { lstatSync } from "node:fs";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArguments } from "../core/cli";
+import {
+  assertUtf8Text,
+  InputEncodingError,
+  readStdinUtf8,
+} from "../core/utf8";
+import {
+  assertPlanArguments,
+  normalizePlanArgumentAliases,
+  PlanArgumentError,
+  REVIEW_USAGE,
+} from "./cli";
+import {
+  assertCandidateRootStable,
+  readCandidateText as readSecureCandidateText,
+} from "./io";
+import {
+  canonicalFacts,
+  acceptanceOptions,
+  expectedAcceptanceLines,
+  expectedBatchCardLines,
+  expectedTaskCardLines,
+  projectionFindings,
+  renderProjection,
+  type Finding,
+} from "./projection";
+import {
+  sectionHeadingCount,
+  unfencedMarkerLines,
+  validateFencedBlocks,
+} from "./markdown";
+import { parseAcceptance } from "./acceptance";
+import { validateCanonicalRawPlan } from "./contract";
+
+export interface PlanValidationResult {
+  status: "pass" | "reject";
+  mode: "explicit-dev-plan";
+  findings: Finding[];
+  output: string | null;
+  execution: "allowed" | "blocked";
+}
+function sourcePath(): string {
+  return process.env.PLAN_REVIEW_ENTRYPOINT_PATH ?? fileURLToPath(import.meta.url);
+}
+function moduleRoot(): string {
+  return process.env.PLAN_REVIEW_ENTRYPOINT_PATH
+    ? resolve(dirname(sourcePath()), "../..")
+    : resolve(dirname(sourcePath()), "../../../..");
+}
+export function candidateRoot(): string {
+  return process.env.PLAN_CONTRACT_REPO_ROOT ?? moduleRoot();
+}
+function assertNoSymlinkComponents(path: string): void {
+  const absolute = resolve(path);
+  const parts = absolute.split("/").filter(Boolean);
+  let current = "/";
+  for (const part of parts) {
+    current = current.endsWith("/")
+      ? `${current}${part}`
+      : `${current}/${part}`;
+    const entry = lstatSync(current);
+    if (entry.isSymbolicLink())
+      throw new Error(`DEV_PLAN_SOURCE_SYMLINK_FORBIDDEN: ${current}`);
+  }
+}
+function assertNotHardlink(path: string): void {
+  const entry = lstatSync(path);
+  if (entry.isFile() && entry.nlink !== 1)
+    throw new Error(`DEV_PLAN_SOURCE_HARDLINK_FORBIDDEN: ${path}`);
+}
+export function validatedCandidateRoot(): string {
+  const source = sourcePath();
+  assertNoSymlinkComponents(source);
+  assertNotHardlink(source);
+  const root = candidateRoot();
+  assertNoSymlinkComponents(root);
+  assertCandidateRootStable(root);
+  return root;
+}
+export async function readCandidateInput(rawPath: string): Promise<string> {
+  const root = validatedCandidateRoot();
+  const requested =
+    rawPath === "-"
+      ? root
+      : isAbsolute(rawPath)
+        ? resolve(rawPath)
+        : resolve(root, rawPath);
+  const relativePath = relative(root, requested);
+  if (
+    !relativePath ||
+    relativePath === ".." ||
+    relativePath.startsWith("../") ||
+    relativePath.startsWith("..\\")
+  )
+    throw new Error(
+      "PLAN_REVIEW_VIEW_INPUT_OUTSIDE_CANDIDATE: --input must resolve inside the candidate Worktree",
+    );
+  return readSecureCandidateText(requested, root);
+}
+
+export async function validateRawPlan(
+  plan: string,
+  signal?: AbortSignal,
+): Promise<Finding[]> {
+  try {
+    assertUtf8Text(plan);
+  } catch {
+    return [
+      {
+        code: "DEV_PLAN_INPUT_ENCODING_INVALID",
+        message: "projection input must be valid UTF-8",
+      },
+    ];
+  }
+  if (plan.includes("\0"))
+    return [
+      {
+        code: "DEV_PLAN_INPUT_NUL_FORBIDDEN",
+        message: "projection input must not contain NUL bytes",
+      },
+    ];
+  if (
+    unfencedMarkerLines(plan, "<proposed_plan>").length ||
+    unfencedMarkerLines(plan, "</proposed_plan>").length
+  )
+    return [
+      {
+        code: "DEV_PLAN_LEGACY_INPUT_FORBIDDEN",
+        message:
+          "projection accepts canonical raw-plan Markdown, not a proposed_plan wrapper",
+      },
+    ];
+  try {
+    validateFencedBlocks(plan);
+  } catch (error) {
+    return [
+      {
+        code: "DEV_PLAN_FENCED_BLOCK_INVALID",
+        message: error instanceof Error ? error.message : String(error),
+      },
+    ];
+  }
+  try {
+    validatedCandidateRoot();
+    if (signal?.aborted) throw new Error("plan review aborted");
+    return validateCanonicalRawPlan(plan);
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    return [
+      {
+        code: "DEV_PLAN_FINALIZER_CHECKER_UNAVAILABLE",
+        message: error instanceof Error ? error.message : String(error),
+      },
+    ];
+  }
+}
+
+export async function finalize(
+  plan: string,
+  signal?: AbortSignal,
+): Promise<PlanValidationResult> {
+  if (signal?.aborted) throw new Error("plan review aborted");
+  const hasWrapper =
+    unfencedMarkerLines(plan, "<proposed_plan>").length > 0 ||
+    unfencedMarkerLines(plan, "</proposed_plan>").length > 0;
+  if (!hasWrapper)
+    for (const name of ["Flow Decision", "Task Orchestration"])
+      if (sectionHeadingCount(plan, name) > 1)
+        return {
+          status: "reject",
+          mode: "explicit-dev-plan",
+          findings: [
+            {
+              code: "DEV_PLAN_DUPLICATE_ROUTING_SECTION",
+              message: `explicit dev-plan contains more than one ${name} section`,
+            },
+          ],
+          output: null,
+          execution: "blocked",
+        };
+  const rawFindings = await validateRawPlan(plan, signal);
+  if (signal?.aborted) throw new Error("plan review aborted");
+  if (rawFindings.length)
+    return {
+      status: "reject",
+      mode: "explicit-dev-plan",
+      findings: rawFindings,
+      output: null,
+      execution: "blocked",
+    };
+  try {
+    const [batches] = canonicalFacts(plan);
+    const output = renderProjection(plan, batches);
+    const acceptance = parseAcceptance(plan, acceptanceOptions(plan));
+    const findings = projectionFindings(
+      output,
+      batches,
+      new Set(acceptance.items.map((item) => item.id)),
+      expectedBatchCardLines(batches),
+      expectedTaskCardLines(batches),
+      expectedAcceptanceLines(plan),
+    );
+    if (findings.length)
+      return {
+        status: "reject",
+        mode: "explicit-dev-plan",
+        findings,
+        output: null,
+        execution: "blocked",
+      };
+    return {
+      status: "pass",
+      mode: "explicit-dev-plan",
+      findings: [],
+      output,
+      execution: "allowed",
+    };
+  } catch {
+    return {
+      status: "reject",
+      mode: "explicit-dev-plan",
+      findings: [
+        {
+          code: "DEV_PLAN_CANONICAL_FACTS_INVALID",
+          message:
+            "canonical facts could not be derived from the validated raw-plan",
+        },
+      ],
+      output: null,
+      execution: "blocked",
+    };
+  }
+}
+
+export async function render(plan: string): Promise<string> {
+  const result = await finalize(plan);
+  if (result.status !== "pass" || result.output === null) {
+    const finding = result.findings[0] ?? {
+      code: "DEV_PLAN_FINALIZATION_REJECTED",
+      message: "plan rejected",
+    };
+    throw new Error(`${finding.code}: ${finding.message}`);
+  }
+  return result.output;
+}
+
+export interface CliWriters {
+  stdout?: (value: string) => void;
+  stderr?: (value: string) => void;
+  signal?: AbortSignal;
+}
+
+export async function cli(
+  argv = process.argv.slice(2),
+  writers: CliWriters = {},
+): Promise<number> {
+  const writeStdout =
+    writers.stdout ?? ((value: string) => process.stdout.write(value));
+  const writeStderr =
+    writers.stderr ?? ((value: string) => process.stderr.write(value));
+  try {
+    const parsed = parseArguments(normalizePlanArgumentAliases(argv));
+    assertPlanArguments(parsed, { values: ["input"], flags: ["help"] });
+    if (parsed.options.has("help")) {
+      writeStdout(REVIEW_USAGE);
+      return 0;
+    }
+    const rawInput = parsed.options.get("input");
+    const input = typeof rawInput === "string" ? rawInput : "-";
+    const plan =
+      input === "-"
+        ? await readStdinUtf8(writers.signal)
+        : await readCandidateInput(input);
+    const result = await finalize(plan, writers.signal);
+    if (result.status === "pass" && result.output !== null) {
+      writeStdout(`<proposed_plan>\n${result.output}\n</proposed_plan>\n`);
+      return 0;
+    }
+    writeStderr(
+      `plan_validation:\n  status: reject\n  mode: explicit-dev-plan\n  findings:\n${result.findings.map((finding) => `    - code: ${finding.code}\n      message: ${finding.message}`).join("\n")}\n  output: none\n  execution: blocked\n`,
+    );
+    return 1;
+  } catch (error) {
+    if (error instanceof PlanArgumentError) {
+      writeStderr(`${REVIEW_USAGE}\nerror: ${error.message}\n`);
+      return 2;
+    }
+    const code =
+      error instanceof InputEncodingError
+        ? "DEV_PLAN_INPUT_ENCODING_INVALID"
+        : "DEV_PLAN_FINALIZATION_INPUT_INVALID";
+    writeStderr(
+      `plan_validation:\n  status: reject\n  mode: explicit-dev-plan\n  findings:\n    - code: ${code}\n      message: ${error instanceof Error ? error.message : String(error)}\n  output: none\n  execution: blocked\n`,
+    );
+    return 1;
+  }
+}

package/toolkit/skills/bin/modules/plan/task_migration.ts

@@ -0,0 +1,308 @@
+import { readFile, writeFile } from "node:fs/promises";
+
+const skillBinding = /\(skill:[^)]+\)/;
+const waveLine = /^\s*-\s*wave:\s*\d+\s*$/;
+const dispatchLine = /^\s*-\s*dispatch:\s*(?:self-run|sub-agents)\s*$/;
+const assignLine =
+  /^\s*-\s*assign:\s*(main-agent|sub-agent:[A-Za-z0-9_.-]+|task:[A-Za-z0-9_.-]+)(?:\s+(\[[^\]]+\]))?\s*=>\s*(.+?)\s*$/;
+const nestedAssignLine =
+  /^(\s*)-\s*assign:\s*(main-agent|sub-agent:[A-Za-z0-9_.-]+|task:[A-Za-z0-9_.-]+)(?:\s+(\[[^\]]+\]))?\s*=>\s*(.+?)\s*$/;
+const nestedTaskLine =
+  /^(\s*)-\s*(main-agent|sub-agent:[A-Za-z0-9_.-]+|task:[A-Za-z0-9_.-]+)(?:\s+(\[[^\]]+\]))?\s*=>\s*(.+?)\s*$/;
+const taskLine =
+  /^\s*-\s*(main-agent|sub-agent:[A-Za-z0-9_.-]+|task:[A-Za-z0-9_.-]+)(?:\s+(\[[^\]]+\]))?\s*=>\s*(.+?)\s*$/;
+const flowType =
+  /[\x60]?flow_type[\x60]?\s*:\s*[\x60]?([^\x60\r\n]+?)[\x60]?\s*$/im;
+const profileMarker =
+  /\b(?:model|model_reasoning_effort|reasoning_effort|effort)\s*=\s*[A-Za-z0-9_.-]+/gi;
+const modelMarker = /\bmodel\s*=\s*(gpt-[A-Za-z0-9.-]+)/i;
+const effortMarker =
+  /\b(?:model_reasoning_effort|reasoning_effort|effort)\s*=\s*([A-Za-z0-9_-]+)/i;
+const profiles: Record<string, Set<string>> = {
+  "gpt-5.6-luna": new Set(["low", "medium", "high", "xhigh", "max"]),
+  "gpt-5.6-terra": new Set(["low", "medium", "high", "xhigh", "max", "ultra"]),
+  "gpt-5.6-sol": new Set(["low", "medium", "high", "xhigh", "max", "ultra"]),
+  "gpt-6.1-sol": new Set(["low", "medium", "high", "xhigh", "max", "ultra"]),
+  "gpt-6.1-terra": new Set(["xhigh"]),
+  "gpt-6-luna": new Set(["low", "medium", "high", "xhigh", "max"]),
+  "gpt-6-sol": new Set(["low", "medium", "high", "xhigh", "max", "ultra"]),
+  "gpt-6-astra": new Set(["low", "medium", "high", "xhigh", "max", "ultra"]),
+};
+const aliases: Record<string, string> = {
+  "$fast-pr-delivery": "$fast-flow",
+  "$codex-review-loop": "$review-agent",
+};
+
+function canonicalFlowType(type: string | undefined): string | undefined {
+  if (type === undefined) return;
+  const normalized = type
+    .trim()
+    .toLowerCase()
+    .replaceAll("_", "-")
+    .replace(/\s+/g, "-");
+  return ["multi-task-flow", "multi-task", "多任务流程"].includes(normalized)
+    ? "multi-task-flow"
+    : normalized;
+}
+
+function sectionRange(
+  text: string,
+  heading: string,
+): [number, number, number] | undefined {
+  const expression = new RegExp("^## " + heading + "\\s*\\r?\\n", "m");
+  const start = text.search(expression);
+  if (start < 0) return undefined;
+  const header = text.slice(start).match(expression);
+  if (!header) return undefined;
+  const bodyStart = start + header[0].length;
+  const next = text.slice(bodyStart).search(/^## /m);
+  return [start, bodyStart, next < 0 ? text.length : bodyStart + next];
+}
+
+function normalizeBindings(bindings: string[]): string | undefined {
+  const unique: string[] = [];
+  for (const binding of bindings) {
+    const inside = binding.slice("(skill:".length, -1);
+    for (const part of inside.split("+")) {
+      const skill = aliases[part.trim()] ?? part.trim();
+      if (skill && !unique.includes(skill)) unique.push(skill);
+    }
+  }
+  for (const primary of [
+    "$normal-flow",
+    "$fast-flow",
+    "$local-merge-flow",
+    "$multi-task-flow",
+  ]) {
+    if (unique.includes(primary)) {
+      const index = unique.indexOf("$project-engineering-workflow");
+      if (index >= 0) unique.splice(index, 1);
+    }
+  }
+  return unique.length ? "(skill: " + unique.join(" + ") + ")" : undefined;
+}
+
+function skillHint(text: string, type: string | undefined): string {
+  if (["multi-task-flow", "multi_task_flow", "multi-task"].includes(type ?? ""))
+    return "(skill: $multi-task-flow)";
+  const execution = sectionRange(text, "Execution Steps");
+  if (execution) {
+    const bindings =
+      text
+        .slice(execution[0], execution[2])
+        .match(new RegExp(skillBinding.source, "g")) ?? [];
+    const merged = normalizeBindings(bindings);
+    if (merged) return merged;
+  }
+  if (
+    [
+      "wave-thread",
+      "wave_thread",
+      "wave-thread-flow",
+      "initiative",
+      "initiative-flow",
+      "initiative_flow",
+      "parallel-pr",
+      "parallel_pr",
+      "parallelpr",
+      "parallel-pr-flow",
+    ].includes(type ?? "")
+  )
+    throw new Error(
+      "Retired coordination flows cannot be migrated; create a multi-task-flow plan explicitly.",
+    );
+  if (["implement-only", "implement_only"].includes(type ?? ""))
+    return "(skill: $implement-only-flow)";
+  if (type === "normal") return "(skill: $normal-flow)";
+  if (["fast-track", "fast_track", "fast-pr", "fastpr"].includes(type ?? ""))
+    return "(skill: $fast-flow)";
+  if (
+    ["local-merge", "local_merge", "localmerge", "local-merge-flow"].includes(
+      type ?? "",
+    )
+  )
+    return "(skill: $local-merge-flow)";
+  return "(skill: $implement-only-flow)";
+}
+
+function ensureSkill(task: string, hint: string): string {
+  const normalized = task
+    .replaceAll("$codex-review-loop", "$review-agent")
+    .trim();
+  return skillBinding.test(normalized) ? normalized : normalized + " " + hint;
+}
+
+function extractProfile(task: string): [string | undefined, string] {
+  const markers = [...task.matchAll(profileMarker)];
+  if (!markers.length) return [undefined, task];
+  const first = markers[0]!;
+  const firstIndex = first.index ?? 0;
+  const prefix = task.slice(0, firstIndex);
+  if (prefix.trim() && !/[;,]\s*$/.test(prefix)) return [undefined, task];
+  let end = firstIndex + first[0].length;
+  for (const marker of markers.slice(1)) {
+    if (!/^[\s,;]*$/.test(task.slice(end, marker.index ?? 0)))
+      return [undefined, task];
+    end = (marker.index ?? 0) + marker[0].length;
+  }
+  const suffix = task.slice(end);
+  if (!/^[\s,;]*(?:\(skill:[^)]+\))?[\s,;]*$/.test(suffix))
+    return [undefined, task];
+  const block = task.slice(firstIndex, end);
+  const model = block.match(modelMarker)?.[1];
+  const effort = block.match(effortMarker)?.[1];
+  let cleaned = prefix.replace(/[\s,;]+$/, "");
+  const skill = suffix.replace(/^[\s,;]+|[\s,;]+$/g, "");
+  if (skill) cleaned = (cleaned + " " + skill).trim();
+  return [
+    model && effort ? "[" + model + ", " + effort + "]" : undefined,
+    cleaned,
+  ];
+}
+
+function validProfile(profile: string | undefined): string | undefined {
+  if (!profile) return undefined;
+  const match = profile.match(/^\[\s*([^,\]]+)\s*,\s*([^\]]+?)\s*\]$/);
+  if (!match) return undefined;
+  const model = match[1]!.trim();
+  const effort = match[2]!.trim();
+  return profiles[model]?.has(effort)
+    ? "[" + model + ", " + effort + "]"
+    : undefined;
+}
+
+function executor(
+  executorName: string,
+  profile: string | undefined,
+  task: string,
+): string {
+  const [legacy, cleaned] = extractProfile(task);
+  const selected = validProfile(profile ?? legacy);
+  if (executorName === "main-agent") return executorName + " => " + cleaned;
+  return (
+    executorName +
+    " " +
+    (selected ?? "[gpt-5.6-luna, xhigh]") +
+    " => " +
+    cleaned
+  );
+}
+
+function convertBody(body: string, hint: string): [string, boolean, string] {
+  const lines = body.split(/\r?\n/);
+  if (lines.some((line) => line.trim() && waveLine.test(line))) {
+    let changed = false;
+    const unsupported: string[] = [];
+    const output = lines.map((line) => {
+      const match = nestedAssignLine.exec(line) ?? nestedTaskLine.exec(line);
+      if (!match) {
+        if (line.trim() && !waveLine.test(line)) unsupported.push(line);
+        return line;
+      }
+      changed = true;
+      return (
+        match[1] +
+        "- " +
+        executor(match[2]!, match[3], ensureSkill(match[4]!, hint))
+      );
+    });
+    if (unsupported.length)
+      return [
+        body,
+        false,
+        "unsupported-existing-wave-lines:" + unsupported.length,
+      ];
+    return [
+      output.join("\n"),
+      changed,
+      changed ? "normalized-existing-wave-format" : "already-wave-format",
+    ];
+  }
+  const items: string[] = [];
+  const unsupported: string[] = [];
+  for (const line of lines) {
+    if (!line.trim() || dispatchLine.test(line)) continue;
+    const match = assignLine.exec(line) ?? taskLine.exec(line);
+    if (!match) {
+      unsupported.push(line);
+      continue;
+    }
+    items.push(
+      "  - " + executor(match[1]!, match[2], ensureSkill(match[3]!, hint)),
+    );
+  }
+  if (unsupported.length)
+    return [body, false, "unsupported-lines:" + unsupported.length];
+  if (!items.length) return [body, false, "no-migratable-task-items"];
+  return ["- wave: 1\n" + items.join("\n"), true, "migrated-to-wave-format"];
+}
+
+export function migrateText(text: string): [string, number, string[]] {
+  const section = sectionRange(text, "Task Orchestration");
+  const type = canonicalFlowType(text.match(flowType)?.[1]);
+  if (
+    [
+      "wave-thread",
+      "wave-thread-flow",
+      "initiative",
+      "initiative-flow",
+      "parallel-pr",
+      "parallelpr",
+      "parallel-pr-flow",
+    ].includes(type ?? "")
+  )
+    throw new Error("Retired coordination flow cannot be migrated.");
+  const hint = skillHint(text, type);
+  let updated = text;
+  let converted = 0;
+  const notes: string[] = [];
+  if (section) {
+    const [newBody, changed, reason] = convertBody(
+      text.slice(section[1], section[2]),
+      hint,
+    );
+    notes.push(reason);
+    if (changed) converted += 1;
+    updated = text.slice(0, section[1]) + newBody + text.slice(section[2]);
+  }
+  const execution = sectionRange(updated, "Execution Steps");
+  if (execution) {
+    updated = updated.slice(0, execution[0]) + updated.slice(execution[2]);
+    converted += 1;
+    notes.push("removed-execution-steps:1");
+  }
+  return [updated.replace(/\n{3,}/g, "\n\n"), converted, notes];
+}
+
+export async function processMigration(
+  path: string,
+  inPlace: boolean,
+): Promise<number> {
+  let original: string;
+  try {
+    original = await readFile(path, "utf8");
+  } catch {
+    console.error("ERROR " + path + ": file not found");
+    return 1;
+  }
+  const [updated, converted, notes] = migrateText(original);
+  if (inPlace && updated !== original) await writeFile(path, updated, "utf8");
+  if (converted)
+    console.log(
+      "MIGRATED " +
+        path +
+        " changes=" +
+        converted +
+        " notes=" +
+        notes.join(","),
+    );
+  else
+    console.log(
+      "SKIPPED " +
+        path +
+        " reason=" +
+        (notes[0] ?? "no-task-orchestration-section"),
+    );
+  if (!inPlace) process.stdout.write(updated);
+  return 0;
+}

package/toolkit/skills/bin/modules/plan/text.ts

@@ -0,0 +1,8 @@
+export function escapeHtml(value: string, quote: boolean): string {
+  let result = value
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;");
+  if (quote) result = result.replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+  return result;
+}

package/toolkit/skills/bin/modules/visual/casefold.ts

@@ -0,0 +1,21 @@
+// Compact full-casefold deltas from JavaScript lowercasing, encoded as code points.
+const SPECIAL_CASEFOLD = new Map<number, number[]>(
+  "b5:3bc;df:73,73;149:2bc,6e;17f:73;1f0:6a,30c;345:3b9;390:3b9,308,301;3b0:3c5,308,301;3c2:3c3;3d0:3b2;3d1:3b8;3d5:3c6;3d6:3c0;3f0:3ba;3f1:3c1;3f5:3b5;587:565,582;13f8:13f0;13f9:13f1;13fa:13f2;13fb:13f3;13fc:13f4;13fd:13f5;1c80:432;1c81:434;1c82:43e;1c83:441;1c84:442;1c85:442;1c86:44a;1c87:463;1c88:a64b;1e96:68,331;1e97:74,308;1e98:77,30a;1e99:79,30a;1e9a:61,2be;1e9b:1e61;1f50:3c5,313;1f52:3c5,313,300;1f54:3c5,313,301;1f56:3c5,313,342;1f80:1f00,3b9;1f81:1f01,3b9;1f82:1f02,3b9;1f83:1f03,3b9;1f84:1f04,3b9;1f85:1f05,3b9;1f86:1f06,3b9;1f87:1f07,3b9;1f90:1f20,3b9;1f91:1f21,3b9;1f92:1f22,3b9;1f93:1f23,3b9;1f94:1f24,3b9;1f95:1f25,3b9;1f96:1f26,3b9;1f97:1f27,3b9;1fa0:1f60,3b9;1fa1:1f61,3b9;1fa2:1f62,3b9;1fa3:1f63,3b9;1fa4:1f64,3b9;1fa5:1f65,3b9;1fa6:1f66,3b9;1fa7:1f67,3b9;1fb2:1f70,3b9;1fb3:3b1,3b9;1fb4:3ac,3b9;1fb6:3b1,342;1fb7:3b1,342,3b9;1fbe:3b9;1fc2:1f74,3b9;1fc3:3b7,3b9;1fc4:3ae,3b9;1fc6:3b7,342;1fc7:3b7,342,3b9;1fd2:3b9,308,300;1fd3:3b9,308,301;1fd6:3b9,342;1fd7:3b9,308,342;1fe2:3c5,308,300;1fe3:3c5,308,301;1fe4:3c1,313;1fe6:3c5,342;1fe7:3c5,308,342;1ff2:1f7c,3b9;1ff3:3c9,3b9;1ff4:3ce,3b9;1ff6:3c9,342;1ff7:3c9,342,3b9;ab70:13a0;ab71:13a1;ab72:13a2;ab73:13a3;ab74:13a4;ab75:13a5;ab76:13a6;ab77:13a7;ab78:13a8;ab79:13a9;ab7a:13aa;ab7b:13ab;ab7c:13ac;ab7d:13ad;ab7e:13ae;ab7f:13af;ab80:13b0;ab81:13b1;ab82:13b2;ab83:13b3;ab84:13b4;ab85:13b5;ab86:13b6;ab87:13b7;ab88:13b8;ab89:13b9;ab8a:13ba;ab8b:13bb;ab8c:13bc;ab8d:13bd;ab8e:13be;ab8f:13bf;ab90:13c0;ab91:13c1;ab92:13c2;ab93:13c3;ab94:13c4;ab95:13c5;ab96:13c6;ab97:13c7;ab98:13c8;ab99:13c9;ab9a:13ca;ab9b:13cb;ab9c:13cc;ab9d:13cd;ab9e:13ce;ab9f:13cf;aba0:13d0;aba1:13d1;aba2:13d2;aba3:13d3;aba4:13d4;aba5:13d5;aba6:13d6;aba7:13d7;aba8:13d8;aba9:13d9;abaa:13da;abab:13db;abac:13dc;abad:13dd;abae:13de;abaf:13df;abb0:13e0;abb1:13e1;abb2:13e2;abb3:13e3;abb4:13e4;abb5:13e5;abb6:13e6;abb7:13e7;abb8:13e8;abb9:13e9;abba:13ea;abbb:13eb;abbc:13ec;abbd:13ed;abbe:13ee;abbf:13ef;fb00:66,66;fb01:66,69;fb02:66,6c;fb03:66,66,69;fb04:66,66,6c;fb05:73,74;fb06:73,74;fb13:574,576;fb14:574,565;fb15:574,56b;fb16:57e,576;fb17:574,56d"
+    .split(";")
+    .map((entry) => {
+      const [source = "", target = ""] = entry.split(":");
+      return [
+        Number.parseInt(source, 16),
+        target.split(",").map((codePoint) => Number.parseInt(codePoint, 16)),
+      ] as [number, number[]];
+    }),
+);
+
+export function casefold(value: string): string {
+  return [...value.toLowerCase()]
+    .map((character) => {
+      const folded = SPECIAL_CASEFOLD.get(character.codePointAt(0) ?? 0);
+      return folded ? String.fromCodePoint(...folded) : character;
+    })
+    .join("");
+}