@warpgogol/werkstatt-shared 0.2.0

package/src/share/tests/content-ref-index.test.ts

@@ -0,0 +1,328 @@
+import { test, expect } from "vitest";
+import {
+  resolveReference,
+  resolveReferencesInString,
+  resolveReferencesDeep,
+  EMPTY_CONTENT_REF_INDEX,
+  type ContentRefIndex,
+  type SourceRef,
+} from "../content-reference.ts";
+
+const TEST_INDEX: ContentRefIndex = {
+  version: 1,
+  generatedAt: "2026-07-25T00:00:00Z",
+  collections: ["business", "pages"],
+  entries: {
+    business: {
+      offer: {
+        de: {
+          price: { monthly: "70 €/Monat", yearly: "700 €/Jahr", setup: "200 € Einrichtung" },
+          growthModules: [{ price: "+19 €/Monat je Stadt" }],
+        },
+      },
+      legal: {
+        de: { companyName: "Warpgogol GmbH" },
+        en: { companyName: "Warpgogol Ltd." },
+      },
+    },
+    pages: {
+      "de/index": {
+        de: { title: "Startseite", subtitle: "Willkommen" },
+      },
+    },
+  },
+};
+
+test("resolveReference — resolves a simple braceless reference", () => {
+  const result = resolveReference(TEST_INDEX, "business.offer.price.monthly", "de", "de");
+  expect(result.resolved).toBe(true);
+  expect(result.value).toBe("70 €/Monat");
+});
+
+test("resolveReference — resolves a nested field path", () => {
+  const result = resolveReference(TEST_INDEX, "business.legal.companyName", "de", "de");
+  expect(result.resolved).toBe(true);
+  expect(result.value).toBe("Warpgogol GmbH");
+});
+
+test("resolveReference — falls back to default language", () => {
+  const result = resolveReference(TEST_INDEX, "business.legal.companyName", "fr", "de");
+  expect(result.resolved).toBe(true);
+  expect(result.value).toBe("Warpgogol GmbH");
+});
+
+test("resolveReference — uses English when lang is en", () => {
+  const result = resolveReference(TEST_INDEX, "business.legal.companyName", "en", "de");
+  expect(result.resolved).toBe(true);
+  expect(result.value).toBe("Warpgogol Ltd.");
+});
+
+test("resolveReference — REF-01: missing collection", () => {
+  const result = resolveReference(TEST_INDEX, "unknown.coll.field", "de", "de");
+  expect(result.resolved).toBe(false);
+  expect(result.error).toContain("REF-01");
+});
+
+test("resolveReference — REF-02: missing file", () => {
+  const result = resolveReference(TEST_INDEX, "business.unknown.field", "de", "de");
+  expect(result.resolved).toBe(false);
+  expect(result.error).toContain("REF-02");
+});
+
+test("resolveReference — REF-03: missing field", () => {
+  const result = resolveReference(TEST_INDEX, "business.offer.price.nonexistent", "de", "de");
+  expect(result.resolved).toBe(false);
+  expect(result.error).toContain("REF-03");
+});
+
+test("resolveReference — invalid syntax", () => {
+  const result = resolveReference(TEST_INDEX, "not-a-ref", "de", "de");
+  expect(result.resolved).toBe(false);
+  expect(result.error).toContain("Invalid reference syntax");
+});
+
+test("resolveReferencesInString — pure reference string resolves fully", () => {
+  const out = resolveReferencesInString(TEST_INDEX, "business.offer.price.monthly", "de", "de");
+  expect(out).toBe("70 €/Monat");
+});
+
+test("resolveReferencesInString — embedded references in text", () => {
+  const out = resolveReferencesInString(
+    TEST_INDEX,
+    "Preis: business.offer.price.monthly oder business.offer.price.yearly",
+    "de",
+    "de",
+  );
+  expect(out).toBe("Preis: 70 €/Monat oder 700 €/Jahr");
+});
+
+test("resolveReferencesInString — leaves non-reference text untouched", () => {
+  const text = "Hello world, no references here.";
+  const out = resolveReferencesInString(TEST_INDEX, text, "de", "de");
+  expect(out).toBe(text);
+});
+
+test("resolveReferencesInString — empty index leaves text untouched", () => {
+  const text = "business.offer.price.monthly should stay as-is";
+  const out = resolveReferencesInString(EMPTY_CONTENT_REF_INDEX, text, "de", "de");
+  expect(out).toBe(text);
+});
+
+test("resolveReferencesDeep — resolves references in nested objects", async () => {
+  const data = {
+    title: "business.offer.price.monthly",
+    nested: { price: "business.offer.price.yearly" },
+    list: ["business.offer.price.setup", "plain text"],
+    number: 42,
+  };
+  const out = await resolveReferencesDeep(TEST_INDEX, data, "de", "de");
+  expect(out).toEqual({
+    title: "70 €/Monat",
+    nested: { price: "700 €/Jahr" },
+    list: ["200 € Einrichtung", "plain text"],
+    number: 42,
+  });
+});
+
+test("resolveReferencesDeep — handles arrays of objects", async () => {
+  const data = [{ name: "business.legal.companyName" }, { name: "plain" }];
+  const out = await resolveReferencesDeep(TEST_INDEX, data, "de", "de");
+  expect(out).toEqual([{ name: "Warpgogol GmbH" }, { name: "plain" }]);
+});
+
+test("resolveReferencesDeep — empty index returns data unchanged", async () => {
+  const data = { text: "business.offer.price.monthly" };
+  const out = await resolveReferencesDeep(EMPTY_CONTENT_REF_INDEX, data, "de", "de");
+  expect(out).toEqual(data);
+});
+
+// RFC-0570: Formula expression integration tests
+
+test("resolveReferencesInString — formula with two references and arithmetic", () => {
+  const out = resolveReferencesInString(
+    TEST_INDEX,
+    "=(business.offer.price.setup + business.offer.price.monthly * 12)",
+    "de",
+    "de",
+  );
+  expect(out).toBe("1040");
+});
+
+test("resolveReferencesInString — formula with surrounding text and unit suffix", () => {
+  const out = resolveReferencesInString(
+    TEST_INDEX,
+    "Total: =(business.offer.price.setup + business.offer.price.monthly * 12) €",
+    "de",
+    "de",
+  );
+  expect(out).toBe("Total: 1040 €");
+});
+
+test("resolveReferencesInString — formula and braceless refs coexist", () => {
+  const out = resolveReferencesInString(
+    TEST_INDEX,
+    "=(business.offer.price.setup + business.offer.price.monthly) and business.offer.price.yearly",
+    "de",
+    "de",
+  );
+  expect(out).toBe("270 and 700 €/Jahr");
+});
+
+test("resolveReferencesInString — formula with unresolved ref renders empty", () => {
+  const out = resolveReferencesInString(
+    TEST_INDEX,
+    "Total: =(business.offer.price.nonexistent + 100) €",
+    "de",
+    "de",
+  );
+  expect(out).toBe("Total:  €");
+});
+
+test("resolveReferencesInString — string without formulas is unchanged", () => {
+  const text = "business.offer.price.monthly is the price";
+  const out = resolveReferencesInString(TEST_INDEX, text, "de", "de");
+  expect(out).toBe("70 €/Monat is the price");
+});
+
+test("resolveReferencesInString — formula with nested parentheses", () => {
+  const out = resolveReferencesInString(
+    TEST_INDEX,
+    "=((business.offer.price.setup + business.offer.price.monthly) * 2)",
+    "de",
+    "de",
+  );
+  expect(out).toBe("540");
+});
+
+test("resolveReferencesInString — overlapping prefix references do not corrupt each other", () => {
+  const index: ContentRefIndex = {
+    ...TEST_INDEX,
+    entries: {
+      ...TEST_INDEX.entries,
+      business: {
+        ...TEST_INDEX.entries.business,
+        place: {
+          de: {
+            address: {
+              street: "Elly-Heuss-Knapp-Weg",
+              streetNumber: "29",
+              postalCode: "71522",
+              locality: "Backnang",
+            },
+          },
+        },
+      },
+    },
+  };
+  const out = resolveReferencesInString(
+    index,
+    "business.place.address.street business.place.address.streetNumber business.place.address.postalCode business.place.address.locality",
+    "de",
+    "de",
+  );
+  expect(out).toBe("Elly-Heuss-Knapp-Weg 29 71522 Backnang");
+});
+
+test("resolveReferencesInString — trailing period from sentence punctuation is not included in reference", () => {
+  const out = resolveReferencesInString(
+    TEST_INDEX,
+    "Bei Fragen wenden Sie sich an business.legal.companyName.",
+    "de",
+    "de",
+  );
+  expect(out).toBe("Bei Fragen wenden Sie sich an Warpgogol GmbH.");
+});
+
+test("resolveReferencesInString — reference followed by comma resolves correctly", () => {
+  const out = resolveReferencesInString(
+    TEST_INDEX,
+    "Preis: business.offer.price.monthly, jährlich.",
+    "de",
+    "de",
+  );
+  expect(out).toBe("Preis: 70 €/Monat, jährlich.");
+});
+
+test("resolveReferencesInString — reference at end of line without trailing punctuation resolves", () => {
+  const out = resolveReferencesInString(
+    TEST_INDEX,
+    "Kontakt: business.legal.companyName",
+    "de",
+    "de",
+  );
+  expect(out).toBe("Kontakt: Warpgogol GmbH");
+});
+
+// RFC-0731: this. self-reference tests
+
+const OFFER_SOURCE_REF: SourceRef = { collection: "business", file: "offer" };
+
+test("RFC-0731: resolveReference with this. prefix and sourceRef — resolves to same-file field", () => {
+  const result = resolveReference(TEST_INDEX, "this.price.monthly", "de", "de", OFFER_SOURCE_REF);
+  expect(result.resolved).toBe(true);
+  expect(result.value).toBe("70 €/Monat");
+});
+
+test("RFC-0731: resolveReference with this. prefix but no sourceRef — returns REF-12", () => {
+  const result = resolveReference(TEST_INDEX, "this.price.monthly", "de", "de");
+  expect(result.resolved).toBe(false);
+  expect(result.error).toContain("REF-12");
+});
+
+test("RFC-0731: resolveReference with this. prefix, sourceRef provided, but field not found — returns REF-13", () => {
+  const result = resolveReference(
+    TEST_INDEX,
+    "this.nonexistent.field",
+    "de",
+    "de",
+    OFFER_SOURCE_REF,
+  );
+  expect(result.resolved).toBe(false);
+  expect(result.error).toContain("REF-13");
+});
+
+test("RFC-0731: resolveReferencesInString with this. as pure reference — resolves correctly", () => {
+  const out = resolveReferencesInString(
+    TEST_INDEX,
+    "this.price.monthly",
+    "de",
+    "de",
+    OFFER_SOURCE_REF,
+  );
+  expect(out).toBe("70 €/Monat");
+});
+
+test("RFC-0731: resolveReferencesInString with this. in embedded text — resolves correctly", () => {
+  const out = resolveReferencesInString(
+    TEST_INDEX,
+    "Preis: this.price.monthly monatlich",
+    "de",
+    "de",
+    OFFER_SOURCE_REF,
+  );
+  expect(out).toBe("Preis: 70 €/Monat monatlich");
+});
+
+test("RFC-0731: resolveReferencesDeep with this. in nested object — resolves correctly", async () => {
+  const data = {
+    label: "Monatlicher Preis",
+    value: "this.price.monthly",
+    nested: { description: "Kosten: this.price.monthly" },
+  };
+  const result = await resolveReferencesDeep(TEST_INDEX, data, "de", "de", OFFER_SOURCE_REF);
+  expect(result).toEqual({
+    label: "Monatlicher Preis",
+    value: "70 €/Monat",
+    nested: { description: "Kosten: 70 €/Monat" },
+  });
+});
+
+test("RFC-0731: resolveReferencesInString with this. but no sourceRef — leaves text unchanged", () => {
+  const out = resolveReferencesInString(TEST_INDEX, "this.price.monthly", "de", "de");
+  expect(out).toBe("this.price.monthly");
+});
+
+test("RFC-0731: regression — existing absolute references still resolve without sourceRef", () => {
+  const out = resolveReferencesInString(TEST_INDEX, "business.offer.price.monthly", "de", "de");
+  expect(out).toBe("70 €/Monat");
+});

package/src/share/tests/create-dev-props-validator.test.ts

@@ -0,0 +1,38 @@
+import { test, expect } from "vitest";
+import { createDevPropsValidator } from "../dev-props-validator.ts";
+
+/*
+<MODULE_CONTRACT>
+<purpose>
+  RFC-0262: end-to-end test of createDevPropsValidator against the real
+  packages/werkstatt-site/src/domain/ui/sections/hero manifest (this test runs from within the
+  actual monorepo checkout, so workspace-root discovery resolves for real).
+</purpose>
+</MODULE_CONTRACT>
+*/
+
+test("createDevPropsValidator: passes valid Europa (hero-section) props", async () => {
+  const validate = createDevPropsValidator();
+  await validate("Europa", { header: { heading: "Hello" } }, "hero-block"); // cosmic-literals-ignore: fixture cosmicName exercising the real hero-section manifest
+});
+
+test("createDevPropsValidator: throws PAGE-PROPS-01 on an undeclared prop key", async () => {
+  const validate = createDevPropsValidator();
+  try {
+    await validate(
+      "Europa", // cosmic-literals-ignore: fixture cosmicName exercising the real hero-section manifest
+      { header: { heading: "Hello" }, totallyUnknownField: true },
+      "hero-block",
+    ); // cosmic-literals-ignore: fixture cosmicName exercising the real hero-section manifest
+    expect.fail("should have thrown");
+  } catch (error) {
+    expect(error).toBeInstanceOf(Error);
+    expect((error as Error).message).toMatch(/PAGE-PROPS-01/);
+    expect((error as Error).message).toMatch(/hero-block/);
+  }
+});
+
+test("createDevPropsValidator: an unknown planetName resolves no schema and does not throw", async () => {
+  const validate = createDevPropsValidator();
+  await validate("NotARealPlanet", { anything: true }, null);
+});

package/src/share/tests/derivation.test.ts

@@ -0,0 +1,39 @@
+/*
+<MODULE_CONTRACT>
+<purpose>RFC-0215: tests for normalized hashing + derived-state comparison.</purpose>
+<keywords>RFC-0215, CKL, derivation, test</keywords>
+</MODULE_CONTRACT>
+<MODULE_MAP><entry key="tests">normalize stability, hash sensitivity, derivedState transitions.</entry></MODULE_MAP>
+<CHANGE_SUMMARY><item>RFC-0215: initial derivation tests.</item></CHANGE_SUMMARY>
+*/
+
+import { test, expect } from "vitest";
+import { normalizeForHash, hashSourceValue, derivedState } from "../knowledge/derivation.ts";
+
+test("normalize: whitespace and markdown are insensitive", () => {
+  expect(normalizeForHash("Hello   world")).toBe("Hello world");
+  expect(normalizeForHash("**Hello** _world_")).toBe("Hello world");
+  expect(hashSourceValue("Hello world")).toBe(hashSourceValue("**Hello**   world"));
+});
+
+test("hash: wording change is sensitive", () => {
+  expect(hashSourceValue("Price is 70 EUR")).not.toBe(hashSourceValue("Price is 80 EUR"));
+});
+
+test("derivedState: current when hash matches", () => {
+  const h = hashSourceValue("Digitales Fundament");
+  expect(derivedState(h, "Digitales Fundament").state).toBe("current");
+});
+
+test("derivedState: outdated when source changed", () => {
+  const h = hashSourceValue("old source");
+  expect(derivedState(h, "new source").state).toBe("outdated");
+});
+
+test("derivedState: outdated when never stamped", () => {
+  expect(derivedState(undefined, "any").state).toBe("outdated");
+});
+
+test("derivedState: source-missing when source value absent", () => {
+  expect(derivedState("sha256:x", undefined).state).toBe("source-missing");
+});

package/src/share/tests/dev-props-validator.test.ts

@@ -0,0 +1,88 @@
+import { test, expect } from "vitest";
+import { buildPage, type PageEntry } from "../page.ts";
+import { EMPTY_RUNTIME_CONTEXT } from "../runtime-context.ts";
+
+/*
+<MODULE_CONTRACT>
+<purpose>
+  RFC-0262: verify buildPage's validateProps hook is called per resolved
+  block (with the block id) and that a thrown violation propagates —
+  buildPage never swallows a validateProps error (fail-fast contract).
+</purpose>
+<non-goals>
+  <item>Do not test real propsSchema resolution here — see dev-props-validator's own schema-shape checks, exercised indirectly via props-contract.test.ts's validateExampleAgainstSchema (identical logic).</item>
+</non-goals>
+</MODULE_CONTRACT>
+*/
+
+function fixtureEntry(): PageEntry {
+  return {
+    kind: "page",
+    cosmicStar: "TestStar",
+    title: "Test",
+    description: "Test page",
+    lang: "en",
+    blocks: [
+      {
+        id: "fixture-block",
+        type: "FixturePlanet",
+        props: { extra: "not-in-schema" },
+      },
+    ],
+  };
+}
+
+test("buildPage: validateProps is called with planetName, props, and blockId", async () => {
+  const entry = fixtureEntry();
+  const ctx = EMPTY_RUNTIME_CONTEXT("en");
+  const calls: Array<{
+    planetName: string;
+    props: Record<string, unknown>;
+    blockId: string | null;
+  }> = [];
+
+  const page = await buildPage(entry, ctx, {
+    resolveImportPath: () => "@warpgogol/werkstatt-site/ui/sections/fixture-section.astro",
+    validateProps: async (planetName, props, blockId) => {
+      calls.push({ planetName, props, blockId });
+    },
+  });
+
+  expect(page.blocks.length).toBe(1);
+  expect(calls.length).toBe(1);
+  expect(calls[0]?.planetName).toBe("FixturePlanet");
+  expect(calls[0]?.blockId).toBe("fixture-block");
+  expect(calls[0]?.props).toEqual({ extra: "not-in-schema" });
+});
+
+test("buildPage: a validateProps throw (PAGE-PROPS-01) propagates and includes the block id", async () => {
+  const entry = fixtureEntry();
+  const ctx = EMPTY_RUNTIME_CONTEXT("en");
+
+  try {
+    await buildPage(entry, ctx, {
+      resolveImportPath: () => "@warpgogol/werkstatt-site/ui/sections/fixture-section.astro",
+      validateProps: async (_planetName, props, blockId) => {
+        if ("extra" in props) {
+          throw new Error(
+            `[PAGE-PROPS-01] block "${blockId}" (FixturePlanet): unknown property "extra"`,
+          );
+        }
+      },
+    });
+    expect.fail("should have thrown");
+  } catch (error) {
+    expect(error).toBeInstanceOf(Error);
+    expect((error as Error).message).toMatch(/PAGE-PROPS-01/);
+    expect((error as Error).message).toMatch(/fixture-block/);
+  }
+});
+
+test("buildPage: without validateProps, no hook is invoked (opt-in, zero behavior change)", async () => {
+  const entry = fixtureEntry();
+  const ctx = EMPTY_RUNTIME_CONTEXT("en");
+  const page = await buildPage(entry, ctx, {
+    resolveImportPath: () => "@warpgogol/werkstatt-site/ui/sections/fixture-section.astro",
+  });
+  expect(page.blocks.length).toBe(1);
+});

package/src/share/tests/fleet-catalog.test.ts

@@ -0,0 +1,134 @@
+/*
+<MODULE_CONTRACT>
+<purpose>RFC-0292: determinism + shape tests for the Fleet Agent Catalog builder.</purpose>
+<keywords>RFC-0292, fleet, agent catalog, test</keywords>
+</MODULE_CONTRACT>
+<MODULE_MAP>
+  <entry key="tests">determinism, missing-doc entry, sorting, hash stability, empty-input safe default.</entry>
+</MODULE_MAP>
+<CHANGE_SUMMARY>
+  <item>RFC-0292: initial builder tests.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { test, expect } from "vitest";
+import {
+  buildFleetAgentCatalog,
+  computeFleetCatalogContentHash,
+  FLEET_AGENT_CATALOG_SCHEMA,
+} from "../agent/fleet-catalog.ts";
+
+const sampleDoc = {
+  surfaceVersion: "1.0.0",
+  site: "warpgogol-com",
+  baseUrl: "https://warpgogol.com",
+  contentHash: "abc123",
+  knowledge: [
+    { domain: "offer", url: "/api/agent/v1/offer.json", schema: "gogol.agent.knowledge/offer@1" },
+  ],
+  actions: [
+    {
+      id: "lead.submit",
+      url: "/api/agent/actions/lead.submit",
+      title: { de: "Anfrage" },
+      inputSchemaRef: "#/x",
+      entitlement: "agent.actions",
+    },
+  ],
+  interfaces: {
+    llms: "/llms.txt",
+    twins: { pattern: "/**.md" },
+    openapi: "/.well-known/agent.openapi.json",
+    mcp: { url: "/api/agent/mcp", protocolVersion: "1" },
+  },
+  proof: null,
+};
+
+test("buildFleetAgentCatalog: missing doc ⇒ enabled: false entry", () => {
+  const catalog = buildFleetAgentCatalog([{ site: "alpha", doc: null }]);
+  expect(catalog.sites).toHaveLength(1);
+  expect(catalog.sites[0]!.enabled).toBe(false);
+  expect(catalog.sites[0]!.signed).toBe(false);
+  expect(catalog.sites[0]!.knowledgeDomains).toEqual([]);
+  expect(catalog.sites[0]!.actions).toEqual([]);
+  expect(catalog.sites[0]!.baseUrl).toBe("");
+});
+
+test("buildFleetAgentCatalog: populated doc ⇒ enabled: true with extracted fields", () => {
+  const catalog = buildFleetAgentCatalog([{ site: "alpha", doc: sampleDoc }]);
+  const entry = catalog.sites[0]!;
+  expect(entry.enabled).toBe(true);
+  expect(entry.signed).toBe(false);
+  expect(entry.baseUrl).toBe("https://warpgogol.com");
+  expect(entry.surfaceVersion).toBe("1.0.0");
+  expect(entry.contentHash).toBe("abc123");
+  expect(entry.knowledgeDomains).toEqual(["offer"]);
+  expect(entry.actions).toEqual(["lead.submit"]);
+  expect(entry.interfaces).toEqual({ openapi: true, mcp: true });
+});
+
+test("buildFleetAgentCatalog: proof present ⇒ signed: true", () => {
+  const catalog = buildFleetAgentCatalog([
+    {
+      site: "alpha",
+      doc: {
+        ...sampleDoc,
+        proof: { type: "Ed25519Signature2020", verificationMethod: "k", proofValue: "v" },
+      },
+    },
+  ]);
+  expect(catalog.sites[0]!.signed).toBe(true);
+});
+
+test("buildFleetAgentCatalog: sorts sites by site id", () => {
+  const catalog = buildFleetAgentCatalog([
+    { site: "zeta", doc: null },
+    { site: "alpha", doc: null },
+    { site: "mid", doc: null },
+  ]);
+  expect(catalog.sites.map((s) => s.site)).toEqual(["alpha", "mid", "zeta"]);
+});
+
+test("buildFleetAgentCatalog: is deterministic across repeated calls (byte-identical)", () => {
+  const input = [
+    { site: "alpha", doc: sampleDoc },
+    { site: "beta", doc: null },
+  ];
+  const a = buildFleetAgentCatalog(input);
+  const b = buildFleetAgentCatalog(input);
+  expect(JSON.stringify(a)).toBe(JSON.stringify(b));
+  expect(a.contentHash).toBe(b.contentHash);
+});
+
+test("buildFleetAgentCatalog: empty input ⇒ valid catalog with empty sites", () => {
+  const catalog = buildFleetAgentCatalog([]);
+  expect(catalog.sites).toEqual([]);
+  expect(catalog.schema).toBe(FLEET_AGENT_CATALOG_SCHEMA);
+  expect(catalog.contentHash).toMatch(/^[0-9a-f]{64}$/);
+});
+
+test("buildFleetAgentCatalog: contentHash is a 64-char lowercase hex sha256", () => {
+  const catalog = buildFleetAgentCatalog([{ site: "alpha", doc: sampleDoc }]);
+  expect(catalog.contentHash).toMatch(/^[0-9a-f]{64}$/);
+});
+
+test("computeFleetCatalogContentHash: matches the builder's hash for the same sites", () => {
+  const catalog = buildFleetAgentCatalog([
+    { site: "alpha", doc: sampleDoc },
+    { site: "beta", doc: null },
+  ]);
+  const recomputed = computeFleetCatalogContentHash(catalog.sites);
+  expect(recomputed).toBe(catalog.contentHash);
+});
+
+test("buildFleetAgentCatalog: input array order does not affect output (sorted)", () => {
+  const a = buildFleetAgentCatalog([
+    { site: "alpha", doc: sampleDoc },
+    { site: "beta", doc: null },
+  ]);
+  const b = buildFleetAgentCatalog([
+    { site: "beta", doc: null },
+    { site: "alpha", doc: sampleDoc },
+  ]);
+  expect(JSON.stringify(a)).toBe(JSON.stringify(b));
+});