@fedify/vocab 2.0.0-dev.241 → 2.0.0-dev.323

package/dist/vocab.test.js

@@ -2,9 +2,10 @@
       import { Temporal } from "@js-temporal/polyfill";
       globalThis.addEventListener = () => {};
     
-import { Activity, Announce, Collection, Create, CryptographicKey, Follow, Hashtag, LanguageString, Link, Note, Object as Object$1, OrderedCollectionPage, Person, Place, Question, Source, decodeMultibase, mockDocumentLoader, test, vocab_exports } from "./vocab-BmxSLhXr.js";
+import { Activity, Announce, Collection, Create, CryptographicKey, Follow, Hashtag, Link, Note, Object as Object$1, OrderedCollectionPage, Person, Place, Question, Source, mockDocumentLoader, test, vocab_exports } from "./vocab-B4nUNXTL.js";
 import { assertInstanceOf } from "./utils-Dm0Onkcz.js";
 import { deepStrictEqual, notDeepStrictEqual, ok, rejects, throws } from "node:assert/strict";
+import { LanguageString, decodeMultibase } from "@fedify/vocab-runtime";
 import { pascalCase } from "es-toolkit";
 import { areAllScalarTypes, loadSchemaFiles } from "@fedify/vocab-tools";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab",
-  "version": "2.0.0-dev.241+58c8126c",
+  "version": "2.0.0-dev.323+1d796545",
   "homepage": "https://fedify.dev/",
   "repository": {
     "type": "git",
@@ -47,8 +47,9 @@
     "jsonld": "^9.0.0",
     "multicodec": "^3.2.1",
     "pkijs": "^3.3.3",
-    "@fedify/vocab-tools": "2.0.0-dev.241+58c8126c",
-    "@fedify/webfinger": "2.0.0-dev.241+58c8126c"
+    "@fedify/webfinger": "2.0.0-dev.323+1d796545",
+    "@fedify/vocab-runtime": "2.0.0-dev.323+1d796545",
+    "@fedify/vocab-tools": "2.0.0-dev.323+1d796545"
   },
   "devDependencies": {
     "@types/node": "^22.17.0",
@@ -56,8 +57,7 @@
     "fetch-mock": "^12.5.4",
     "tsdown": "^0.12.9",
     "typescript": "^5.9.3",
-    "@fedify/fixture": "2.0.0",
-    "@fedify/vocab-runtime": "2.0.0-dev.241+58c8126c"
+    "@fedify/fixture": "2.0.0"
   },
   "keywords": [
     "Fedify",
@@ -74,7 +74,9 @@
     "build:self": "deno task compile && tsdown",
     "build": "pnpm --filter @fedify/vocab... run build:self",
     "prepublish": "pnpm build",
-    "test": "pnpm build && cd dist/ && node --test",
-    "test:bun": "pnpm build && cd dist/ && bun test --timeout 60000"
+    "pretest": "pnpm build",
+    "test": "cd dist/ && node --test",
+    "pretest:bun": "pnpm build",
+    "test:bun": "cd dist/ && bun test --timeout 60000"
   }
 }

package/scripts/codegen.ts

@@ -1,18 +1,154 @@
+import $ from "@david/dax";
+import type { Path } from "@david/dax";
 import { generateVocab } from "@fedify/vocab-tools";
-import { rename } from "node:fs/promises";
-import { dirname, join } from "node:path";
 
-async function codegen() {
-  const scriptsDir = import.meta.dirname;
-  if (!scriptsDir) {
-    throw new Error("Could not determine schema directory");
+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 from all YAML files in the schema directory.
+ */
+async function getLatestSourceMtime(schemaDir: Path): Promise<number> {
+  let latestMtime = 0;
+  for await (const entry of schemaDir.readDir()) {
+    if (!entry.isFile) continue;
+    if (!entry.name.match(/\.ya?ml$/i)) continue;
+    if (entry.name === "schema.yaml") continue;
+    const fileStat = await schemaDir.join(entry.name).stat();
+    if (fileStat?.mtime && fileStat.mtime.getTime() > latestMtime) {
+      latestMtime = fileStat.mtime.getTime();
+    }
+  }
+  return latestMtime;
+}
+
+/**
+ * Check if the generated file is up to date compared to source files.
+ */
+async function isUpToDate(
+  schemaDir: Path,
+  generatedPath: Path,
+): Promise<boolean> {
+  try {
+    const [sourceMtime, generatedStat] = await Promise.all([
+      getLatestSourceMtime(schemaDir),
+      generatedPath.stat(),
+    ]);
+    if (!generatedStat?.mtime) return false;
+    return generatedStat.mtime.getTime() >= sourceMtime;
+  } 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);
+    }
   }
-  const schemaDir = join(dirname(scriptsDir), "src");
-  const generatedPath = join(schemaDir, `vocab-${crypto.randomUUID()}.ts`);
-  const realPath = join(schemaDir, "vocab.ts");
+}
+
+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 {
+    // Check if regeneration is needed (after acquiring lock)
+    if (await isUpToDate(schemaDir, realPath)) {
+      $.log("vocab.ts is up to date, skipping codegen");
+      return;
+    }
 
-  await generateVocab(schemaDir, generatedPath);
-  await rename(generatedPath, realPath);
+    $.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) {

package/src/lookup.test.ts

@@ -267,6 +267,21 @@ test("traverseCollection()", {
       new Note({ content: "This is a third simple note" }),
     ],
   );
+  // Inline-paged collection (CollectionPage embedded without id, with next)
+  const inlinePagedCollection = await lookupObject(
+    "https://example.com/inline-paged-collection",
+    options,
+  );
+  assertInstanceOf(inlinePagedCollection, Collection);
+  deepStrictEqual(
+    await Array.fromAsync(
+      traverseCollection(inlinePagedCollection, options),
+    ),
+    [
+      new Note({ content: "Inline first note" }),
+      new Note({ content: "Inline second note" }),
+    ],
+  );
 });
 
 test("FEP-fe34: lookupObject() cross-origin security", {

package/src/lookup.ts

@@ -299,14 +299,14 @@ export async function* traverseCollection(
   collection: Collection,
   options: TraverseCollectionOptions = {},
 ): AsyncIterable<Object | Link> {
-  if (collection.firstId == null) {
+  const interval = Temporal.Duration.from(options.interval ?? { seconds: 0 })
+    .total("millisecond");
+  let page = await collection.getFirst(options);
+  if (page == null) {
     for await (const item of collection.getItems(options)) {
       yield item;
     }
   } else {
-    const interval = Temporal.Duration.from(options.interval ?? { seconds: 0 })
-      .total("millisecond");
-    let page = await collection.getFirst(options);
     while (page != null) {
       for await (const item of page.getItems(options)) {
         yield item;

package/src/mod.ts

@@ -55,3 +55,9 @@ export * from "./handle.ts";
 export * from "./lookup.ts";
 export * from "./type.ts";
 export * from "./vocab.ts";
+export { LanguageString } from "@fedify/vocab-runtime";
+export type {
+  DocumentLoader,
+  GetUserAgentOptions,
+  RemoteDocument,
+} from "@fedify/vocab-runtime";