@fedify/vocab 2.5.0-dev.2496 → 2.5.0-dev.2504

package/dist-tests/vocab.test.mjs

@@ -2,7 +2,7 @@ import { Temporal } from "temporal-polyfill";
 globalThis.addEventListener = () => {};
 import { i as __toESM } from "./rolldown-runtime-BWJg4WE8.mjs";
 import { t as esm_default } from "./esm-BIqRhjGA.mjs";
-import { A as Object$1, B as QuoteAuthorization, C as Intent, D as Measure, E as Link, F as Person, G as Tombstone, H as Reject, I as Place, L as PropertyValue, N as OrderedCollectionPage, O as Multikey, P as Organization, R as Proposal, S as Image, T as InteractionRule, U as Service, V as QuoteRequest, W as Source, Z as vocab_exports, _ as FeaturedCollection, a as Application, b as Group, d as CryptographicKey, f as Delete, g as FeatureRequest, h as FeatureAuthorization, i as Announce, j as Offer, k as Note, l as Commitment, m as Endpoints, n as Activity, p as Document, r as Agreement, s as Collection, t as Accept, u as Create, v as FeaturedItem, w as InteractionPolicy, x as Hashtag, y as Follow, z as Question } from "./vocab-BMEyHiOV.mjs";
+import { A as Object$1, B as QuoteAuthorization, C as Intent, D as Measure, E as Link, F as Person, G as Tombstone, H as Reject, I as Place, L as PropertyValue, N as OrderedCollectionPage, O as Multikey, P as Organization, R as Proposal, S as Image, T as InteractionRule, U as Service, V as QuoteRequest, W as Source, Z as vocab_exports, _ as FeaturedCollection, a as Application, b as Group, d as CryptographicKey, f as Delete, g as FeatureRequest, h as FeatureAuthorization, i as Announce, j as Offer, k as Note, l as Commitment, m as Endpoints, n as Activity, p as Document, r as Agreement, s as Collection, t as Accept, u as Create, v as FeaturedItem, w as InteractionPolicy, x as Hashtag, y as Follow, z as Question } from "./vocab-BmIsd6gR.mjs";
 import { t as assertInstanceOf } from "./utils-Df2odC27.mjs";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, notDeepStrictEqual, ok, rejects, strictEqual, throws } from "node:assert/strict";
@@ -17,7 +17,7 @@ import { areAllScalarTypes, loadSchemaFiles } from "@fedify/vocab-tools";
 import { inspect } from "node:util";
 //#region ../vocab-runtime/deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.5.0-dev.2496+e18c05f8";
+var version = "2.5.0-dev.2504+fdeb138d";
 //#endregion
 //#region ../vocab-runtime/src/url.ts
 var UrlError = class extends Error {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab",
-  "version": "2.5.0-dev.2496+e18c05f8",
+  "version": "2.5.0-dev.2504+fdeb138d",
   "homepage": "https://fedify.dev/",
   "repository": {
     "type": "git",
@@ -43,11 +43,13 @@
     "jsonld": "^9.0.0",
     "pkijs": "^3.3.3",
     "temporal-polyfill": "^1.0.1",
-    "@fedify/vocab-tools": "2.5.0-dev.2496+e18c05f8",
-    "@fedify/webfinger": "2.5.0-dev.2496+e18c05f8",
-    "@fedify/vocab-runtime": "2.5.0-dev.2496+e18c05f8"
+    "@fedify/vocab-tools": "2.5.0-dev.2504+fdeb138d",
+    "@fedify/vocab-runtime": "2.5.0-dev.2504+fdeb138d",
+    "@fedify/webfinger": "2.5.0-dev.2504+fdeb138d"
   },
   "devDependencies": {
+    "@dprint/formatter": "0.6.0",
+    "@dprint/typescript": "0.96.1",
     "@types/node": "^24.12.2",
     "fast-check": "^3.22.0",
     "fetch-mock": "^12.5.4",
@@ -67,7 +69,7 @@
   },
   "license": "MIT",
   "scripts": {
-    "build:self": "deno task compile && tsdown",
+    "build:self": "node --experimental-strip-types scripts/codegen.ts && tsdown",
     "build": "pnpm --filter @fedify/vocab... run build:self",
     "prepublish": "pnpm build",
     "pretest": "pnpm build",

package/scripts/codegen.test.ts

@@ -0,0 +1,234 @@
+import { deepStrictEqual, equal, rejects } from "node:assert/strict";
+import {
+  mkdir,
+  mkdtemp,
+  readdir,
+  readFile,
+  rm,
+  stat,
+  utimes,
+  writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { it } from "node:test";
+import { setTimeout } from "node:timers/promises";
+import {
+  acquireLock,
+  codegen,
+  formatGenerated,
+  getLatestMtimeUnder,
+  isUpToDate,
+} from "./codegen_lib.ts";
+
+async function fixture() {
+  const root = await mkdtemp(join(tmpdir(), "fedify-codegen-"));
+  const packageDir = join(root, "vocab");
+  const src = join(packageDir, "src");
+  const tools = join(root, "vocab-tools");
+  await mkdir(src, { recursive: true });
+  await mkdir(join(packageDir, "scripts"));
+  await mkdir(join(tools, "src"), { recursive: true });
+  const inputs = [
+    join(src, "object.yaml"),
+    join(src, "extension.YmL"),
+    join(tools, "src", "generate.ts"),
+    join(tools, "src", "schema.yaml"),
+    join(packageDir, "scripts", "codegen_lib.ts"),
+    join(tools, "deno.json"),
+    join(packageDir, "package.json"),
+  ];
+  const old = new Date(Date.now() - 60_000);
+  for (const file of inputs) {
+    await writeFile(file, "input");
+    await utimes(file, old, old);
+  }
+  return {
+    root,
+    packageDir,
+    src,
+    inputs,
+    output: join(src, "vocab.ts"),
+    lock: join(packageDir, ".vocab-codegen.lock"),
+    async cleanup() {
+      await rm(root, { recursive: true, force: true });
+    },
+  };
+}
+
+it("regenerates for every schema, generator, helper and metadata input", async () => {
+  const f = await fixture();
+  let generations = 0;
+  const options = {
+    packageDir: f.packageDir,
+    async generate(_schema: string, destination: string) {
+      generations++;
+      await writeFile(
+        destination,
+        `export const generation = ${generations};\n`,
+      );
+    },
+    format: (source: string) => source,
+  };
+  try {
+    await codegen(options);
+    equal(generations, 1);
+    const mtime = (await stat(f.output)).mtimeMs;
+    await codegen(options);
+    equal(generations, 1);
+    equal((await stat(f.output)).mtimeMs, mtime);
+    for (const input of f.inputs) {
+      const original = new Date(Date.now() - 60_000);
+      for (const other of f.inputs) await utimes(other, original, original);
+      // Put the output in the past rather than depending on clock precision.
+      const old = new Date(Date.now() - 30_000);
+      await utimes(f.output, old, old);
+      const changed = new Date(Date.now() - 10_000);
+      await utimes(input, changed, changed);
+      const before: number = generations;
+      await codegen(options);
+      equal(generations, before + 1, input);
+    }
+    await rm(f.output);
+    await codegen(options);
+    equal(await isUpToDate(f.src, f.output, 0), true);
+    equal(await getLatestMtimeUnder(join(f.root, "missing"), [".ts"]), 0);
+    await rejects(stat(f.lock), { code: "ENOENT" });
+  } finally {
+    await f.cleanup();
+  }
+});
+
+it("formats before publishing and preserves the old output on failure", async () => {
+  const f = await fixture();
+  try {
+    for (const stage of ["generate", "format"]) {
+      await writeFile(f.output, "old output");
+      const old = new Date(Date.now() - 120_000);
+      await utimes(f.output, old, old);
+      await rejects(
+        codegen({
+          packageDir: f.packageDir,
+          async generate(_schema, destination) {
+            await writeFile(destination, "partial output");
+            if (stage === "generate") throw new Error("generation failed");
+          },
+          format() {
+            throw new Error("formatting failed");
+          },
+        }),
+        /failed/,
+      );
+      equal(await readFile(f.output, "utf8"), "old output");
+      deepStrictEqual((await readdir(f.src)).sort(), [
+        "extension.YmL",
+        "object.yaml",
+        "vocab.ts",
+      ]);
+      await rejects(stat(f.lock), { code: "ENOENT" });
+    }
+    await codegen({
+      packageDir: f.packageDir,
+      async generate(_schema, destination) {
+        await writeFile(destination, "const value=1");
+      },
+      format: formatGenerated,
+    });
+    const output = await readFile(f.output, "utf8");
+    equal(output, "const value = 1;\n");
+    equal(await formatGenerated(output), output);
+  } finally {
+    await f.cleanup();
+  }
+});
+
+it("concurrent generation rechecks freshness inside the lock", async () => {
+  const f = await fixture();
+  let generations = 0;
+  try {
+    const options = {
+      packageDir: f.packageDir,
+      lockOptions: { retryMs: 5 },
+      async generate(_schema: string, destination: string) {
+        generations++;
+        await setTimeout(20);
+        await writeFile(destination, "complete output");
+      },
+      format: (source: string) => source,
+    };
+    await Promise.all([codegen(options), codegen(options), codegen(options)]);
+    equal(generations, 1);
+    equal(await readFile(f.output, "utf8"), "complete output");
+    await rejects(stat(f.lock), { code: "ENOENT" });
+  } finally {
+    await f.cleanup();
+  }
+});
+
+it("waits for held and initializing locks, and bounds the wait", async () => {
+  const f = await fixture();
+  try {
+    const held = await acquireLock(f.lock);
+    try {
+      await rejects(
+        acquireLock(f.lock, { retryMs: 5, timeoutMs: 20 }),
+        /Timeout waiting for lock/,
+      );
+      await stat(join(f.lock, "info"));
+    } finally {
+      await held.release();
+    }
+    await mkdir(f.lock); // The creator hasn't written info yet.
+    await rejects(
+      acquireLock(f.lock, {
+        retryMs: 5,
+        timeoutMs: 20,
+        initializationMs: 10_000,
+      }),
+      /Timeout waiting for lock/,
+    );
+    await stat(f.lock);
+  } finally {
+    await f.cleanup();
+  }
+});
+
+it("recovers abandoned complete and incomplete locks", async () => {
+  const f = await fixture();
+  try {
+    for (const withInfo of [false, true]) {
+      await mkdir(f.lock);
+      const path = withInfo ? join(f.lock, "info") : f.lock;
+      if (withInfo) await writeFile(path, "abandoned");
+      const old = new Date(Date.now() - 600_000);
+      await utimes(path, old, old);
+      const lock = await acquireLock(f.lock, { retryMs: 5, timeoutMs: 50 });
+      await stat(join(f.lock, "info"));
+      await lock.release();
+      await rejects(stat(f.lock), { code: "ENOENT" });
+    }
+  } finally {
+    await f.cleanup();
+  }
+});
+
+it("stabilizes long generated expressions with Deno's formatting", async () => {
+  const source = `class Sample {
+  method() {
+    let _27fgyFbosTtMAhuepJH8K3ZGURT6__array = values["http://www.ontology-of-units-of-measure.org/resource/om-2/hasUnit"];
+  }
+}`;
+  const formatted = await formatGenerated(source);
+  equal(await formatGenerated(formatted), formatted);
+  equal(
+    formatted,
+    `class Sample {
+  method() {
+    let _27fgyFbosTtMAhuepJH8K3ZGURT6__array = values[
+      "http://www.ontology-of-units-of-measure.org/resource/om-2/hasUnit"
+    ];
+  }
+}
+`,
+  );
+});

package/scripts/codegen.ts

@@ -1,181 +1,3 @@
-import $ from "@david/dax";
-import type { Path } from "@david/dax";
-import { generateVocab } from "@fedify/vocab-tools";
+import { codegen } from "./codegen_lib.ts";
 
-const LOCK_STALE_MS = 5 * 60 * 1000; // 5 minutes
-const LOCK_RETRY_MS = 100;
-const LOCK_TIMEOUT_MS = 60 * 1000; // 1 minute
-
-/**
- * Get the latest mtime among files under a directory tree (recursively),
- * limited to the given file extensions.  Returns 0 if the directory is absent.
- */
-async function getLatestMtimeUnder(
-  dir: Path,
-  exts: readonly string[],
-): Promise<number> {
-  if (!(await dir.exists())) return 0;
-  let latestMtime = 0;
-  for await (const entry of Deno.readDir(dir.toString())) {
-    const child = dir.join(entry.name);
-    if (entry.isDirectory) {
-      const mtime = await getLatestMtimeUnder(child, exts);
-      if (mtime > latestMtime) latestMtime = mtime;
-    } else if (entry.isFile && exts.some((ext) => entry.name.endsWith(ext))) {
-      const fileStat = await child.stat();
-      const mtime = fileStat?.mtime?.getTime() ?? 0;
-      if (mtime > latestMtime) latestMtime = mtime;
-    }
-  }
-  return latestMtime;
-}
-
-/**
- * Check if the generated file is up to date compared to its source files,
- * including the generator itself (`@fedify/vocab-tools` and this codegen
- * script): changing the generator changes the generated output, so the
- * generated file must be at least as new as those too.
- */
-async function isUpToDate(
-  schemaDir: Path,
-  generatedPath: Path,
-  generatorMtime: number,
-): Promise<boolean> {
-  try {
-    const [sourceMtime, generatedStat] = await Promise.all([
-      // Match loadSchemaFiles()'s /\.ya?ml$/i: a .yml schema is a real input.
-      getLatestMtimeUnder(schemaDir, [".yaml", ".yml"]),
-      generatedPath.stat(),
-    ]);
-    if (!generatedStat?.mtime) return false;
-    return generatedStat.mtime.getTime() >=
-      Math.max(sourceMtime, generatorMtime);
-  } catch {
-    // If generated file doesn't exist, it's not up to date
-    return false;
-  }
-}
-
-interface Lock {
-  release(): Promise<void>;
-}
-
-/**
- * Acquire a directory-based lock. mkdir is atomic on POSIX systems.
- */
-async function acquireLock(lockPath: Path): Promise<Lock> {
-  const startTime = Date.now();
-
-  while (true) {
-    try {
-      // Use Deno.mkdir directly because dax's mkdir() is recursive by default
-      await Deno.mkdir(lockPath.toString());
-      // Write PID and timestamp for stale lock detection
-      const infoPath = lockPath.join("info");
-      await infoPath.writeJsonPretty({ pid: Deno.pid, timestamp: Date.now() });
-      return {
-        async release() {
-          try {
-            await lockPath.remove({ recursive: true });
-          } catch {
-            // Ignore errors during cleanup
-          }
-        },
-      };
-    } catch (e) {
-      if (!(e instanceof Deno.errors.AlreadyExists)) {
-        throw e;
-      }
-
-      // Check if lock is stale
-      try {
-        const infoPath = lockPath.join("info");
-        const infoStat = await infoPath.stat();
-        if (
-          infoStat?.mtime &&
-          Date.now() - infoStat.mtime.getTime() > LOCK_STALE_MS
-        ) {
-          console.warn("Removing stale lock:", lockPath.toString());
-          await lockPath.remove({ recursive: true });
-          continue;
-        }
-      } catch {
-        // If we can't read the info file, try to remove the lock
-        try {
-          await lockPath.remove({ recursive: true });
-          continue;
-        } catch {
-          // Ignore
-        }
-      }
-
-      // Check timeout
-      if (Date.now() - startTime > LOCK_TIMEOUT_MS) {
-        throw new Error(`Timeout waiting for lock: ${lockPath}`);
-      }
-
-      // Wait and retry
-      await $.sleep(LOCK_RETRY_MS);
-    }
-  }
-}
-
-async function codegen() {
-  const scriptsDir = $.path(import.meta.dirname!);
-  const packageDir = scriptsDir.parent()!;
-  const schemaDir = packageDir.join("src");
-  const realPath = schemaDir.join("vocab.ts");
-  const lockPath = packageDir.join(".vocab-codegen.lock");
-
-  // Acquire lock to prevent concurrent codegen
-  const lock = await acquireLock(lockPath);
-  try {
-    // The generated vocab.ts depends not only on the YAML schemas but on the
-    // generator itself: @fedify/vocab-tools and this codegen script.  Sample
-    // its mtime inside the lock so that a generator edit made while we were
-    // waiting for the lock is not missed by the freshness check below.
-    const generatorMtime = Math.max(
-      await getLatestMtimeUnder(
-        packageDir.parent()!.join("vocab-tools", "src"),
-        [".ts", ".yaml", ".yml"],
-      ),
-      await getLatestMtimeUnder(scriptsDir, [".ts"]),
-    );
-
-    // Check if regeneration is needed (after acquiring lock)
-    if (await isUpToDate(schemaDir, realPath, generatorMtime)) {
-      $.log("vocab.ts is up to date, skipping codegen");
-      return;
-    }
-
-    $.logStep("Generating", "vocab.ts...");
-
-    // Generate to a temporary file first
-    const generatedPath = schemaDir.join(`vocab-${crypto.randomUUID()}.ts`);
-    try {
-      await generateVocab(schemaDir.toString(), generatedPath.toString());
-      await generatedPath.rename(realPath);
-    } catch (e) {
-      // Clean up temp file on error
-      await generatedPath.remove().catch(() => {});
-      throw e;
-    }
-
-    $.logStep("Formatting", "vocab.ts...");
-    await $`deno fmt ${realPath}`;
-
-    $.logStep("Caching", "vocab.ts...");
-    await $`deno cache ${realPath}`;
-
-    $.logStep("Type checking", "vocab.ts...");
-    await $`deno check ${realPath}`;
-
-    $.logStep("Codegen", "completed successfully");
-  } finally {
-    await lock.release();
-  }
-}
-
-if (import.meta.main) {
-  await codegen();
-}
+await codegen();

package/scripts/codegen_lib.ts

@@ -0,0 +1,228 @@
+import { createContext } from "@dprint/formatter";
+import { getPath } from "@dprint/typescript";
+import { randomUUID } from "node:crypto";
+import {
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  stat,
+  writeFile,
+} from "node:fs/promises";
+import { join, resolve } from "node:path";
+import process from "node:process";
+import { setTimeout } from "node:timers/promises";
+// Use source before any workspace package has been built on a fresh checkout.
+import { generateVocab } from "../../vocab-tools/src/mod.ts";
+
+function hasCode(error: unknown, code: string): boolean {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+
+/** Find the newest matching input, including nested directories. */
+export async function getLatestMtimeUnder(
+  dir: string,
+  exts: readonly string[],
+): Promise<number> {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch (error) {
+    if (hasCode(error, "ENOENT")) return 0;
+    throw error;
+  }
+  let latest = 0;
+  for (const entry of entries) {
+    const child = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      latest = Math.max(latest, await getLatestMtimeUnder(child, exts));
+    } else if (
+      entry.isFile() &&
+      exts.some((ext) => entry.name.toLowerCase().endsWith(ext))
+    ) {
+      latest = Math.max(latest, (await stat(child)).mtimeMs);
+    }
+  }
+  return latest;
+}
+
+/** Check freshness after taking the generation lock. */
+export async function isUpToDate(
+  schemaDir: string,
+  generatedPath: string,
+  generatorMtime: number,
+): Promise<boolean> {
+  try {
+    const [sourceMtime, generatedStat] = await Promise.all([
+      getLatestMtimeUnder(schemaDir, [".yaml", ".yml"]),
+      stat(generatedPath),
+    ]);
+    return generatedStat.mtimeMs >= Math.max(sourceMtime, generatorMtime);
+  } catch (error) {
+    if (hasCode(error, "ENOENT")) return false;
+    throw error;
+  }
+}
+
+interface LockOptions {
+  staleMs: number;
+  initializationMs: number;
+  retryMs: number;
+  timeoutMs: number;
+}
+
+/** Acquire the same directory lock used by Node and Deno generation. */
+export async function acquireLock(
+  lockPath: string,
+  options: Partial<LockOptions> = {},
+): Promise<{ release(): Promise<void> }> {
+  const {
+    staleMs = 5 * 60 * 1000,
+    initializationMs = 10 * 1000,
+    retryMs = 100,
+    timeoutMs = 60 * 1000,
+  } = options;
+  const startTime = Date.now();
+  while (true) {
+    try {
+      // Non-recursive mkdir is atomic, including on Windows.
+      await mkdir(lockPath);
+    } catch (error) {
+      if (!hasCode(error, "EEXIST")) throw error;
+      try {
+        let age: number;
+        let threshold: number;
+        try {
+          age = Date.now() - (await stat(join(lockPath, "info"))).mtimeMs;
+          threshold = staleMs;
+        } catch (infoError) {
+          if (!hasCode(infoError, "ENOENT")) throw infoError;
+          // Another process may still be writing info after its mkdir.
+          age = Date.now() - (await stat(lockPath)).mtimeMs;
+          threshold = initializationMs;
+        }
+        if (age > threshold) {
+          console.warn("Removing stale lock:", lockPath);
+          await rm(lockPath, { recursive: true, force: true });
+          continue;
+        }
+      } catch (statError) {
+        if (!hasCode(statError, "ENOENT")) throw statError;
+        continue; // The holder released the lock while we inspected it.
+      }
+      if (Date.now() - startTime > timeoutMs) {
+        throw new Error(`Timeout waiting for lock: ${lockPath}`);
+      }
+      await setTimeout(retryMs);
+      continue;
+    }
+
+    try {
+      await writeFile(
+        join(lockPath, "info"),
+        JSON.stringify({ pid: process.pid, timestamp: Date.now() }) + "\n",
+      );
+    } catch (error) {
+      await rm(lockPath, { recursive: true, force: true }).catch(() => {});
+      throw error;
+    }
+    return {
+      async release() {
+        await rm(lockPath, { recursive: true, force: true }).catch(() => {});
+      },
+    };
+  }
+}
+
+let formatter: Promise<ReturnType<typeof createContext>> | undefined;
+
+/**
+ * Preserve Deno's generated-code formatting without requiring Deno at bootstrap.
+ *
+ * TODO(#1285): Replace dprint with Oxfmt when migrating repository formatting.
+ * Switch the generated-code checks and formatting exclusions together so Deno
+ * and Oxfmt never compete over vocab.ts, then remove the dprint dependencies
+ * and Deno-version coupling in mise.toml.  The vocab-tools code snapshots record
+ * unformatted generator output, so a formatter change alone need not alter them.
+ * https://github.com/fedify-dev/fedify/issues/1285
+ */
+export async function formatGenerated(source: string): Promise<string> {
+  formatter ??= (async () => {
+    const context = createContext({
+      lineWidth: 80,
+      indentWidth: 2,
+      useTabs: false,
+      newLineKind: "lf",
+    });
+    context.addPlugin(await readFile(getPath()), { deno: true });
+    return context;
+  })();
+  const context = await formatter;
+  // Like Deno's format_ensure_stable(), keep formatting until the result is
+  // stable. Some long generated expressions need more than one dprint pass.
+  let current = source;
+  for (let pass = 0; pass < 6; pass++) {
+    const next = context.formatText({
+      filePath: "vocab.ts",
+      fileText: current,
+    });
+    if (next === current) return current;
+    current = next;
+  }
+  throw new Error("Generated vocabulary formatting did not stabilize");
+}
+
+interface CodegenOptions {
+  packageDir?: string;
+  generate?: typeof generateVocab;
+  format?: (source: string) => string | Promise<string>;
+  lockOptions?: Partial<LockOptions>;
+}
+
+/** Generate and format vocabulary atomically, or leave a fresh output alone. */
+export async function codegen(options: CodegenOptions = {}): Promise<void> {
+  const packageDir = options.packageDir ?? resolve(import.meta.dirname!, "..");
+  const scriptsDir = join(packageDir, "scripts");
+  const schemaDir = join(packageDir, "src");
+  const generatedPath = join(schemaDir, "vocab.ts");
+  const toolsDir = resolve(packageDir, "../vocab-tools");
+  const lock = await acquireLock(
+    join(packageDir, ".vocab-codegen.lock"),
+    options.lockOptions,
+  );
+  try {
+    // Keep these inputs aligned with [deps.codegen].sources in mise.toml.
+    const generatorMtime = Math.max(
+      await getLatestMtimeUnder(join(toolsDir, "src"), [
+        ".ts",
+        ".yaml",
+        ".yml",
+      ]),
+      await getLatestMtimeUnder(scriptsDir, [".ts"]),
+      (await stat(join(toolsDir, "deno.json"))).mtimeMs,
+      (await stat(join(packageDir, "package.json"))).mtimeMs,
+    );
+    if (await isUpToDate(schemaDir, generatedPath, generatorMtime)) {
+      console.log("vocab.ts is up to date, skipping codegen");
+      return;
+    }
+
+    console.log("Generating vocab.ts...");
+    const temporaryPath = join(schemaDir, `vocab-${randomUUID()}.ts`);
+    try {
+      await (options.generate ?? generateVocab)(schemaDir, temporaryPath);
+      const formatted = await (options.format ?? formatGenerated)(
+        await readFile(temporaryPath, "utf8"),
+      );
+      await writeFile(temporaryPath, formatted);
+      // Publish only a complete, formatted file. Failed runs preserve vocab.ts.
+      await rename(temporaryPath, generatedPath);
+    } finally {
+      await rm(temporaryPath, { force: true }).catch(() => {});
+    }
+    console.log("Codegen completed successfully");
+  } finally {
+    await lock.release();
+  }
+}