@warpgogol/werkstatt-shared 0.2.0

package/src/passport/tests/schema.test.ts

@@ -0,0 +1,222 @@
+import { test, expect, describe } from "vitest";
+import {
+  PassportSchema,
+  PassportPublicKeyFileSchema,
+  PassportPublicKeyEntrySchema,
+} from "../schema.ts";
+
+const validHash = "sha256:" + "a".repeat(64);
+
+const validPassport = {
+  schemaVersion: "1.0",
+  appId: "test-app",
+  issuedAt: "2026-01-01T00:00:00Z",
+  composition: {
+    systemHash: validHash,
+    constellation: "test-constellation",
+    biome: "default",
+    stars: [
+      {
+        route: "/de/home",
+        cosmicStar: "Vega",
+        planets: [{ cosmicPlanet: "Europa", pin: "v1", semanticId: "hero" }],
+      },
+    ],
+  },
+  provenance: {
+    commitSha: "abc123",
+    commitAt: "2026-01-01T00:00:00Z",
+    builtAt: "2026-01-01T00:00:00Z",
+    buildDurationMs: 5000,
+    builder: "agent",
+    keyVersion: "v1",
+    verifiableCredential: {
+      "@context": ["https://www.w3.org/2018/credentials/v1"],
+      type: ["VerifiableCredential"],
+      issuer: "did:web:example.com",
+      issuanceDate: "2026-01-01T00:00:00Z",
+      credentialSubject: {
+        id: "did:web:example.com",
+        systemHash: validHash,
+        commitSha: "abc123",
+      },
+      proof: {
+        type: "Ed25519Signature2020",
+        created: "2026-01-01T00:00:00Z",
+        verificationMethod: "did:web:example.com#key-1",
+        proofPurpose: "assertionMethod",
+        proofValue: "zDummySignatureValue",
+      },
+    },
+  },
+  scores: {
+    nebula: 85,
+    pillars: {
+      performance: { score: 90, weight: 0.25 },
+      accessibility: { score: 85, weight: 0.25 },
+      contentHealth: { score: 80, weight: 0.25 },
+      architecturalCompliance: { score: 85, weight: 0.25 },
+    },
+  },
+  links: {
+    starMapSvg: "/star-map.svg",
+    publicKey: "/.well-known/cosmic-passport-key.json",
+    dnaReport: "/dna-report.json",
+  },
+};
+
+describe("PassportSchema", () => {
+  test("accepts a valid passport", () => {
+    expect(PassportSchema.safeParse(validPassport).success).toBe(true);
+  });
+
+  test("rejects wrong schemaVersion", () => {
+    expect(PassportSchema.safeParse({ ...validPassport, schemaVersion: "2.0" }).success).toBe(
+      false,
+    );
+  });
+
+  test("rejects empty appId", () => {
+    expect(PassportSchema.safeParse({ ...validPassport, appId: "" }).success).toBe(false);
+  });
+
+  test("rejects invalid systemHash format", () => {
+    expect(
+      PassportSchema.safeParse({
+        ...validPassport,
+        composition: { ...validPassport.composition, systemHash: "not-a-hash" },
+      }).success,
+    ).toBe(false);
+  });
+
+  test("rejects nebula score out of range", () => {
+    expect(
+      PassportSchema.safeParse({
+        ...validPassport,
+        scores: { ...validPassport.scores, nebula: 150 },
+      }).success,
+    ).toBe(false);
+  });
+
+  test("rejects negative pillar score", () => {
+    expect(
+      PassportSchema.safeParse({
+        ...validPassport,
+        scores: {
+          ...validPassport.scores,
+          pillars: {
+            ...validPassport.scores.pillars,
+            performance: { score: -10, weight: 0.25 },
+          },
+        },
+      }).success,
+    ).toBe(false);
+  });
+
+  test("rejects negative buildDurationMs", () => {
+    expect(
+      PassportSchema.safeParse({
+        ...validPassport,
+        provenance: { ...validPassport.provenance, buildDurationMs: -1 },
+      }).success,
+    ).toBe(false);
+  });
+
+  test("rejects wrong proof type", () => {
+    expect(
+      PassportSchema.safeParse({
+        ...validPassport,
+        provenance: {
+          ...validPassport.provenance,
+          verifiableCredential: {
+            ...validPassport.provenance.verifiableCredential,
+            proof: {
+              ...validPassport.provenance.verifiableCredential.proof,
+              type: "WrongType",
+            },
+          },
+        },
+      }).success,
+    ).toBe(false);
+  });
+
+  test("defaults stars to empty array when omitted", () => {
+    const { stars, ...withoutStars } = validPassport.composition;
+    const result = PassportSchema.safeParse({
+      ...validPassport,
+      composition: withoutStars,
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.composition.stars).toEqual([]);
+    }
+  });
+});
+
+describe("PassportPublicKeyEntrySchema", () => {
+  test("accepts a valid key entry", () => {
+    expect(
+      PassportPublicKeyEntrySchema.safeParse({
+        version: "v1",
+        active: true,
+        type: "Ed25519VerificationKey2020",
+        publicKeyMultibase: "z6MkhaXgBZDvotDkL5m7XJ5n",
+        createdAt: "2026-01-01T00:00:00Z",
+      }).success,
+    ).toBe(true);
+  });
+
+  test("rejects publicKeyMultibase without z prefix", () => {
+    expect(
+      PassportPublicKeyEntrySchema.safeParse({
+        version: "v1",
+        active: true,
+        type: "Ed25519VerificationKey2020",
+        publicKeyMultibase: "6MkhaXgBZDvotDkL5m7XJ5n",
+        createdAt: "2026-01-01T00:00:00Z",
+      }).success,
+    ).toBe(false);
+  });
+
+  test("rejects wrong type", () => {
+    expect(
+      PassportPublicKeyEntrySchema.safeParse({
+        version: "v1",
+        active: true,
+        type: "WrongType",
+        publicKeyMultibase: "z6MkhaXgBZDvotDkL5m7XJ5n",
+        createdAt: "2026-01-01T00:00:00Z",
+      }).success,
+    ).toBe(false);
+  });
+});
+
+describe("PassportPublicKeyFileSchema", () => {
+  test("accepts a file with at least one key", () => {
+    expect(
+      PassportPublicKeyFileSchema.safeParse({
+        schemaVersion: "1.0",
+        appId: "test-app",
+        keys: [
+          {
+            version: "v1",
+            active: true,
+            type: "Ed25519VerificationKey2020",
+            publicKeyMultibase: "z6MkhaXgBZDvotDkL5m7XJ5n",
+            createdAt: "2026-01-01T00:00:00Z",
+          },
+        ],
+      }).success,
+    ).toBe(true);
+  });
+
+  test("rejects empty keys array", () => {
+    expect(
+      PassportPublicKeyFileSchema.safeParse({
+        schemaVersion: "1.0",
+        appId: "test-app",
+        keys: [],
+      }).success,
+    ).toBe(false);
+  });
+});

package/src/passport/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+    include: ["src/**/*.test.ts"],
+  },
+});

package/src/share/agent/api-catalog.ts

@@ -0,0 +1,77 @@
+/*
+<MODULE_CONTRACT>
+<purpose>
+RFC-0783: pure, dependency-free formatter that projects a site's Agent Surface
+Manifest into an RFC 9727 linkset+json document for /.well-known/api-catalog.
+No I/O — the kernel command loads the manifest and passes it here.
+</purpose>
+<non-goals>
+  <item>Do not read files — callers load and pass the manifest.</item>
+  <item>Do not sign — signing is a separate concern (agent.surface.sign).</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0783: initial API Catalog linkset+json projection.</item>
+</CHANGE_SUMMARY>
+*/
+
+import type { AgentSurfaceManifest } from "./manifest.ts";
+
+/** RFC 9264 linkset+json link object — no `rel` (it's the key in the linkset entry). */
+export interface ApiCatalogLink {
+  href: string;
+  type: string;
+  title?: string;
+}
+
+/** RFC 9264 linkset entry — anchor + relation-keyed link arrays. */
+export interface ApiCatalogEntry {
+  anchor: string;
+  [relation: string]: string | ApiCatalogLink[];
+}
+
+/** RFC 9264 linkset document — top-level `linkset` array. */
+export interface ApiCatalog {
+  linkset: ApiCatalogEntry[];
+}
+
+/**
+ * Pure: project Agent Surface Manifest into RFC 9264 linkset+json.
+ * Deterministic — links within each relation are sorted by href for byte-identical output (DNA-58).
+ */
+export function buildApiCatalog(manifest: AgentSurfaceManifest): ApiCatalog {
+  const anchor = manifest.baseUrl.replace(/\/+$/, "") + "/";
+  const entry: ApiCatalogEntry = { anchor };
+
+  const item: ApiCatalogLink[] = manifest.knowledge.map((ref) => ({
+    href: ref.url,
+    type: "application/json",
+    title: ref.domain,
+  }));
+  if (item.length > 0) {
+    item.sort((a, b) => a.href.localeCompare(b.href));
+    entry["item"] = item;
+  }
+
+  entry["service-meta"] = [{ href: "/.well-known/agent.json", type: "application/json" }];
+
+  const serviceDesc: ApiCatalogLink[] = [];
+  if (manifest.interfaces.openapi) {
+    serviceDesc.push({ href: manifest.interfaces.openapi, type: "application/json" });
+  }
+  if (manifest.interfaces.mcp) {
+    serviceDesc.push({ href: "/.well-known/mcp/server-card.json", type: "application/json" });
+  }
+  if (serviceDesc.length > 0) {
+    serviceDesc.sort((a, b) => a.href.localeCompare(b.href));
+    entry["service-desc"] = serviceDesc;
+  }
+
+  if (manifest.interfaces.mcp) {
+    entry["service"] = [{ href: manifest.interfaces.mcp.url, type: "application/json" }];
+  }
+
+  entry["service-doc"] = [{ href: manifest.interfaces.llms, type: "text/plain" }];
+
+  return { linkset: [entry] };
+}

package/src/share/agent/capability.ts

@@ -0,0 +1,68 @@
+/*
+<MODULE_CONTRACT>
+<purpose>
+RFC-0288: pure resolution of the closed capability catalog into the set of
+capabilities ACTIVE on a given site. A capability is active iff the site holds
+`agent.actions`, every additional `requires.entitlements` is held, every
+`requires.sections` archetype renders on some page, and its id is not in
+`agent.actionsDisabled`. Consumed by agent.manifest.generate (RFC-0286) to
+populate `AgentActionRef[]`, and by RFC-0289/0290 to project OpenAPI
+operations and MCP tools.
+</purpose>
+<non-goals>
+  <item>Do not load the catalog from disk or read entitlements/content — the
+        kernel command does that and passes already-loaded data here.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0288: initial capability resolution.</item>
+</CHANGE_SUMMARY>
+*/
+
+import type { CapabilityRecord } from "@warpgogol/werkstatt-shared/ontology";
+import type { AgentActionRef } from "./manifest.ts";
+
+export type { CapabilityRecord } from "@warpgogol/werkstatt-shared/ontology";
+
+export interface ResolveActiveCapabilitiesInput {
+  catalog: CapabilityRecord[];
+  /** Resolved entitlement feature ids (e.g. from entitlements.generated.yaml). */
+  entitlements: string[];
+  /** Section archetypes (blocks[].type) that render on some page of the app. */
+  renderedSectionTypes: string[];
+  /** system.md agent.actionsDisabled — capability ids to withhold even if otherwise active. */
+  actionsDisabled: string[];
+}
+
+/** Pure: gate the closed catalog down to the capabilities active on this site. */
+export function resolveActiveCapabilities(
+  input: ResolveActiveCapabilitiesInput,
+): CapabilityRecord[] {
+  const entitlements = new Set(input.entitlements);
+  const renderedSections = new Set(input.renderedSectionTypes);
+  const disabled = new Set(input.actionsDisabled);
+
+  if (!entitlements.has("agent.actions")) return [];
+
+  return input.catalog.filter((cap) => {
+    if (disabled.has(cap.id)) return false;
+    for (const req of cap.requires.entitlements) {
+      if (!entitlements.has(req)) return false;
+    }
+    for (const section of cap.requires.sections) {
+      if (!renderedSections.has(section)) return false;
+    }
+    return true;
+  });
+}
+
+/** Project one active capability into its manifest AgentActionRef (RFC-0286). */
+export function capabilityToActionRef(cap: CapabilityRecord): AgentActionRef {
+  return {
+    id: cap.id,
+    url: `/api/agent/actions/${cap.id}`,
+    title: cap.title,
+    inputSchemaRef: `#/components/schemas/${cap.id}-input`,
+    entitlement: "agent.actions",
+  };
+}

package/src/share/agent/dns-aid.test.ts

@@ -0,0 +1,74 @@
+/*
+<MODULE_CONTRACT>
+<purpose>
+RFC-0786: Unit tests for the buildDnsAidRecord pure function.
+Verifies determinism, domain extraction, and content URL construction.
+</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0786: initial unit tests for buildDnsAidRecord.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { describe, it, expect } from "vitest";
+import { buildDnsAidRecord } from "@warpgogol/werkstatt-shared/share/agent";
+import type { AgentSurfaceManifest } from "@warpgogol/werkstatt-shared/share/agent";
+
+function makeManifest(baseUrl: string): AgentSurfaceManifest {
+  return {
+    surfaceVersion: "1.0.0",
+    site: "test-site",
+    baseUrl,
+    languages: { default: "de", supported: ["de"] },
+    contentHash: "abc123",
+    knowledge: [],
+    actions: [],
+    interfaces: { llms: "", twins: null, openapi: null, mcp: null },
+    proof: null,
+  };
+}
+
+describe("buildDnsAidRecord (RFC-0786)", () => {
+  it("builds record with _index._agents.<domain> name", () => {
+    const record = buildDnsAidRecord(makeManifest("https://warpgogol.com"));
+    expect(record.name).toBe("_index._agents.warpgogol.com");
+  });
+
+  it("builds record with SVCB type", () => {
+    const record = buildDnsAidRecord(makeManifest("https://warpgogol.com"));
+    expect(record.type).toBe("SVCB");
+  });
+
+  it("builds SVCB content with target, alpn and port params (RFC 9460)", () => {
+    const record = buildDnsAidRecord(makeManifest("https://warpgogol.com"));
+    expect(record.content).toBe("1 warpgogol.com alpn=h2 port=443");
+  });
+
+  it("sets ttl to 3600", () => {
+    const record = buildDnsAidRecord(makeManifest("https://warpgogol.com"));
+    expect(record.ttl).toBe(3600);
+  });
+
+  it("sets proxied to false", () => {
+    const record = buildDnsAidRecord(makeManifest("https://warpgogol.com"));
+    expect(record.proxied).toBe(false);
+  });
+
+  it("is deterministic — same input produces same output (DNA-58)", () => {
+    const manifest = makeManifest("https://example.org");
+    const r1 = buildDnsAidRecord(manifest);
+    const r2 = buildDnsAidRecord(manifest);
+    expect(JSON.stringify(r1)).toBe(JSON.stringify(r2));
+  });
+
+  it("extracts domain from URL with port", () => {
+    const record = buildDnsAidRecord(makeManifest("http://localhost:3000"));
+    expect(record.name).toBe("_index._agents.localhost");
+    expect(record.content).toBe("1 localhost alpn=h2 port=443");
+  });
+
+  it("strips trailing slash from baseUrl", () => {
+    const record = buildDnsAidRecord(makeManifest("https://warpgogol.com/"));
+    expect(record.content).toBe("1 warpgogol.com alpn=h2 port=443");
+  });
+});

package/src/share/agent/dns-aid.ts

@@ -0,0 +1,53 @@
+/*
+<MODULE_CONTRACT>
+<purpose>
+  RFC-0786: Pure projection from AgentSurfaceManifest to DNS-AID SVCB record
+  declaration. DNS-AID is a DNS-based agent discovery mechanism: an SVCB record
+  at _index._agents.<domain> with target pointing to the host serving
+  agent.json, and standard SvcParams (alpn, port) per RFC 9460.
+</purpose>
+<non-goals>
+  <item>Do not perform I/O — this is a pure function (DNA-58).</item>
+  <item>Do not write to dns-records.yaml — that is the command handler's job.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0786: initial DNS-AID record builder — TXT record at _agent.<domain>.</item>
+  <item>RFC-0786: updated to SVCB record at _index._agents.<domain> per DNS-AID spec.</item>
+</CHANGE_SUMMARY>
+*/
+
+import type { AgentSurfaceManifest } from "./manifest.ts";
+
+export interface DnsAidRecord {
+  name: string;
+  type: "SVCB";
+  content: string;
+  ttl: number;
+  proxied: false;
+}
+
+/**
+ * Build the DNS-AID SVCB record declaration from the agent surface manifest.
+ * Pure function — no I/O, no side effects (DNA-58).
+ *
+ * The record name is `_index._agents.<domain>` (per DNS-AID spec).
+ * The record is an SVCB service record (RFC 9460) with:
+ *   priority: 1 (service mode)
+ *   target: <domain> (the host serving agent.json)
+ *   alpn: h2 (HTTP/2)
+ *   port: 443 (HTTPS)
+ * The client resolves the target host, connects via alpn/port, and fetches
+ * /.well-known/agent.json — the path is implied by the DNS-AID spec.
+ * TTL is 3600 seconds (1 hour).
+ */
+export function buildDnsAidRecord(manifest: AgentSurfaceManifest): DnsAidRecord {
+  const domain = new URL(manifest.baseUrl).hostname;
+  return {
+    name: `_index._agents.${domain}`,
+    type: "SVCB",
+    content: `1 ${domain} alpn=h2 port=443`,
+    ttl: 3600,
+    proxied: false,
+  };
+}

package/src/share/agent/fleet-catalog.ts

@@ -0,0 +1,149 @@
+/*
+<MODULE_CONTRACT>
+<purpose>
+RFC-0292: the Fleet Agent Catalog — a deterministic projection of every site's
+public Agent Surface Manifest into one workspace-level discovery document.
+Pure, framework-free assembly: no I/O, no timestamps, sorted-key canonical
+hashing so two runs on unchanged input are byte-identical. Consumed by
+fleet.agent.catalog.generate (site-kernel-checks) and by the Leitstand.
+</purpose>
+<non-goals>
+  <item>Do not read files or network — callers (kernel commands) load each
+        site's agent.json and pass already-parsed data here.</item>
+  <item>Do not aggregate knowledge payloads, leads, or any per-site data —
+        only public discovery metadata (RFC-0176/0177 isolation).</item>
+  <item>Do not add fields absent from the site's own agent.json — the catalog
+        is a projection, never a new source of facts (AS-2 at fleet scale).</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0292: initial fleet catalog contract and pure builder.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { createHash } from "node:crypto";
+import { canonicalJson } from "./manifest.ts";
+
+export const FLEET_AGENT_CATALOG_SCHEMA = "gogol.fleet.agent-catalog@1";
+
+export interface FleetAgentCatalogEntry {
+  site: string;
+  baseUrl: string;
+  surfaceVersion: string;
+  contentHash: string;
+  signed: boolean;
+  enabled: boolean;
+  knowledgeDomains: string[];
+  actions: string[];
+  interfaces: { openapi: boolean; mcp: boolean };
+}
+
+export interface FleetAgentCatalog {
+  schema: typeof FLEET_AGENT_CATALOG_SCHEMA;
+  /** sha256 over sorted-key JSON of `sites` — no timestamps (byte-stable). */
+  contentHash: string;
+  sites: FleetAgentCatalogEntry[];
+}
+
+export interface FleetAgentCatalogSiteInput {
+  site: string;
+  /** Parsed agent.json, or null when the site has no agent surface (agent.enabled: false). */
+  doc: Record<string, unknown> | null;
+}
+
+function sortKeysDeep(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(sortKeysDeep);
+  if (value !== null && typeof value === "object") {
+    const out: Record<string, unknown> = {};
+    for (const key of Object.keys(value as Record<string, unknown>).sort()) {
+      out[key] = sortKeysDeep((value as Record<string, unknown>)[key]);
+    }
+    return out;
+  }
+  return value;
+}
+
+function asString(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}
+
+function _asStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((v): v is string => typeof v === "string");
+}
+
+/**
+ * Extract a catalog entry from one site's parsed agent.json.
+ * Missing doc ⇒ enabled: false entry with empty arrays.
+ */
+function entryFromSiteInput(input: FleetAgentCatalogSiteInput): FleetAgentCatalogEntry {
+  if (!input.doc) {
+    return {
+      site: input.site,
+      baseUrl: "",
+      surfaceVersion: "",
+      contentHash: "",
+      signed: false,
+      enabled: false,
+      knowledgeDomains: [],
+      actions: [],
+      interfaces: { openapi: false, mcp: false },
+    };
+  }
+
+  const doc = input.doc;
+  const knowledge = Array.isArray(doc.knowledge) ? doc.knowledge : [];
+  const actions = Array.isArray(doc.actions) ? doc.actions : [];
+  const interfaces = (doc.interfaces ?? {}) as Record<string, unknown>;
+
+  return {
+    site: input.site,
+    baseUrl: asString(doc.baseUrl) ?? "",
+    surfaceVersion: asString(doc.surfaceVersion) ?? "",
+    contentHash: asString(doc.contentHash) ?? "",
+    signed: doc.proof != null,
+    enabled: true,
+    knowledgeDomains: knowledge
+      .map((ref) => asString((ref as Record<string, unknown>)?.domain))
+      .filter((d): d is string => typeof d === "string")
+      .sort((a, b) => a.localeCompare(b)),
+    actions: actions
+      .map((ref) => asString((ref as Record<string, unknown>)?.id))
+      .filter((d): d is string => typeof d === "string")
+      .sort((a, b) => a.localeCompare(b)),
+    interfaces: {
+      openapi: interfaces.openapi != null,
+      mcp: interfaces.mcp != null,
+    },
+  };
+}
+
+/**
+ * Pure: (fleet sites × loaded discovery docs) → catalog.
+ * Missing doc ⇒ enabled: false entry.
+ * Sites are sorted by site id; entries are deterministic.
+ */
+export function buildFleetAgentCatalog(input: FleetAgentCatalogSiteInput[]): FleetAgentCatalog {
+  const sites = input
+    .slice()
+    .sort((a, b) => a.site.localeCompare(b.site))
+    .map(entryFromSiteInput);
+
+  const contentHash = createHash("sha256").update(canonicalJson(sites), "utf8").digest("hex");
+
+  return {
+    schema: FLEET_AGENT_CATALOG_SCHEMA,
+    contentHash,
+    sites,
+  };
+}
+
+/**
+ * Re-compute the catalog contentHash from a parsed catalog's sites array.
+ * Used by the validator to detect staleness/tampering (FAC-01).
+ */
+export function computeFleetCatalogContentHash(sites: unknown[]): string {
+  return createHash("sha256")
+    .update(JSON.stringify(sortKeysDeep(sites)), "utf8")
+    .digest("hex");
+}

package/src/share/agent/index.ts

@@ -0,0 +1,29 @@
+/*
+<MODULE_CONTRACT>
+<purpose>
+RFC-0286: barrel for the Agent Surface shared model. Re-exports the framework-free
+manifest contract + canonicalization primitives; RFC-0287..0291 add sibling modules
+here (knowledge, capability, openapi, proof) and re-export them from this barrel.
+</purpose>
+<non-goals>
+  <item>Do not add logic here — pure re-export barrel.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0286: initial barrel exporting the manifest module.</item>
+  <item>RFC-0292: re-export fleet-catalog module.</item>
+  <item>RFC-0783: re-export api-catalog and mcp-card modules.</item>
+  <item>RFC-0786: re-export dns-aid module.</item>
+</CHANGE_SUMMARY>
+*/
+
+export * from "./manifest.ts";
+export * from "./knowledge.ts";
+export * from "./capability.ts";
+export * from "./openapi.ts";
+export * from "./omit-empty.ts";
+export * from "./proof.ts";
+export * from "./fleet-catalog.ts";
+export * from "./api-catalog.ts";
+export * from "./mcp-card.ts";
+export * from "./dns-aid.ts";