Narrow portable IRI cache detection

Generated codecs now look for portable ActivityPub IRIs only in
ID-valued JSON-LD positions before deciding whether to bypass the raw
JSON-LD cache. This keeps ordinary text such as post content from
causing cache misses and dropping extension properties on default
serialization.

#850 (comment)
#850 (comment)

Assisted-by: Codex:gpt-5.5

Author: dahlia

packages/vocab-tools/src/__snapshots__/class.test.ts.deno.snap

@@ -3,9 +3,15 @@ import { generateCloner, generateConstructor } from "./constructor.ts";
 import { generateFields } from "./field.ts";
 import { generateInspector, generateInspectorPostClass } from "./inspector.ts";
 import { generateProperties } from "./property.ts";
-import { type TypeSchema, validateTypeSchemas } from "./schema.ts";
+import {
+  type PropertySchema,
+  type TypeSchema,
+  validateTypeSchemas,
+} from "./schema.ts";
 import { emitOverride } from "./type.ts";
 
+const XSD_ANY_URI = "http://www.w3.org/2001/XMLSchema#anyURI";
+
 /**
  * Sorts the given types topologically so that the base types come before the
  * extended types.
@@ -169,6 +175,33 @@ export function getEntityTypeById(id: string | URL): $EntityType | undefined {
 `;
 }
 
+function canContainIriValue(
+  property: PropertySchema,
+  types: Record<string, TypeSchema>,
+): boolean {
+  return property.range.some((typeUri) =>
+    typeUri === XSD_ANY_URI || typeUri in types && types[typeUri].entity
+  );
+}
+
+function addPortableIriKeys(
+  keys: Set<string>,
+  property: PropertySchema,
+  types: Record<string, TypeSchema>,
+): void {
+  if (!canContainIriValue(property, types)) return;
+  keys.add(property.uri);
+  if (property.compactName != null) keys.add(property.compactName);
+  if (property.functional && property.redundantProperties != null) {
+    for (const redundantProperty of property.redundantProperties) {
+      keys.add(redundantProperty.uri);
+      if (redundantProperty.compactName != null) {
+        keys.add(redundantProperty.compactName);
+      }
+    }
+  }
+}
+
 /**
  * Generates the TypeScript classes from the given types.
  * @param types The types to generate classes from.
@@ -210,7 +243,30 @@ export async function* generateClasses(
     isTemporalInstant,
 } from "@fedify/vocab-runtime/temporal";\n`;
   yield "\n\n";
-  yield "const PORTABLE_IRI_PATTERN = /ap(?:\\+ef61)?:\\/\\//i;\n\n";
+  const portableIriKeys = new Set(["@id", "id"]);
+  for (const type of Object.values(types)) {
+    for (const property of type.properties) {
+      addPortableIriKeys(portableIriKeys, property, types);
+    }
+  }
+  yield "const PORTABLE_IRI_PATTERN = /^ap(?:\\+ef61)?:\\/\\//i;\n";
+  yield `const PORTABLE_IRI_KEYS: ReadonlySet<string> = new Set(${
+    JSON.stringify([...portableIriKeys].sort())
+  });\n\n`;
+  yield `function hasPortableIri(value: unknown, key?: string): boolean {
+  if (typeof value === "string") {
+    return key != null && PORTABLE_IRI_KEYS.has(key) &&
+      PORTABLE_IRI_PATTERN.test(value);
+  }
+  if (Array.isArray(value)) {
+    return value.some((item) => hasPortableIri(item, key));
+  }
+  if (value == null || typeof value !== "object") return false;
+  const object = value as Record<string, unknown>;
+  return globalThis.Object.keys(object).some((entryKey) =>
+    hasPortableIri(object[entryKey], entryKey)
+  );
+}\n\n`;
   const moduleVarNames = new Map<string, string>();
   const sorted = sortTopologically(types);
   for (const typeUri of sorted) {

packages/vocab-tools/src/__snapshots__/class.test.ts.node.snap

@@ -535,8 +535,7 @@ export async function* generateDecoder(
   yield `
     if (!("_fromSubclass" in options) || !options._fromSubclass) {
       try {
-        const jsonText = JSON.stringify(json);
-        if (jsonText == null || !PORTABLE_IRI_PATTERN.test(jsonText)) {
+        if (!hasPortableIri(json)) {
           instance._cachedJsonLd = structuredClone(json);
         }
       } catch {

packages/vocab-tools/src/__snapshots__/class.test.ts.snap

@@ -599,6 +599,26 @@ test("fromJsonLd() handles portable ActivityPub IRIs", async () => {
   );
 });
 
+test("fromJsonLd() caches text that mentions portable ActivityPub IRIs", async () => {
+  const noteJson = {
+    "@context": [
+      "https://www.w3.org/ns/activitystreams",
+      { extra: "https://example.com/ns#extra" },
+    ],
+    type: "Note",
+    id: "https://example.com/notes/1",
+    content: "This is text about ap://did:key:z6Mkabc/actor.",
+    extra: "This extension property should stay cached.",
+  };
+
+  const note = await Note.fromJsonLd(noteJson, {
+    documentLoader: mockDocumentLoader,
+    contextLoader: mockDocumentLoader,
+  });
+
+  deepStrictEqual(await note.toJsonLd(), noteJson);
+});
+
 test({
   name: "Activity.getObject()",
   permissions: { env: true, read: true },