ssrwire 0.1.0 → 0.3.0

package/examples/ssrwire.config.yml

@@ -9,6 +9,8 @@ targets:
       canonical: true
       h1: true
       mainText: true
+      openGraph: true
+      twitterCard: true
 
   - url: https://example.com/pricing/
     expectedStatus: 200
@@ -18,6 +20,8 @@ targets:
       canonical: true
       h1: true
       mainText: true
+      openGraph: false
+      twitterCard: false
 
 # Add maxFirstByteMs or maxCriticalMs per target only when the runner location
 # and cache state are stable enough for a meaningful threshold.
@@ -32,6 +36,10 @@ timeoutMs: 15000
 maxBytes: 10485760
 maxRedirects: 10
 
+# Run each target-agent pair sequentially three times to expose intermittent SSR output.
+# Total requests are targets × agents × repeat, plus redirects.
+repeat: 3
+
 # Keep preview credentials in a CI secret or exported environment variable.
 # headers:
 #   x-preview-token: "${PREVIEW_TOKEN}"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ssrwire",
-  "version": "0.1.0",
-  "description": "Inspect streamed SSR HTML, metadata timing, and crawler-specific delivery from the command line.",
+  "version": "0.3.0",
+  "description": "Inspect streamed SSR HTML, SEO and social metadata timing, and crawler-specific delivery from the command line.",
   "type": "module",
   "bin": {
     "ssrwire": "./dist/bin.js"
@@ -52,6 +52,9 @@
     "cli",
     "typescript",
     "seo-tools",
+    "open-graph",
+    "social-preview",
+    "twitter-cards",
     "github-actions",
     "sarif"
   ],

package/src/analyze.ts

@@ -1,3 +1,14 @@
+import {
+  effectiveTwitterCardSignal,
+  firstSocialSignal,
+  isAbsoluteHttpSocialUrl,
+  normalizeSocialValue,
+  OPEN_GRAPH_PROPERTIES,
+  OPEN_GRAPH_REQUIRED_PROPERTIES,
+  socialSignals,
+  TWITTER_CARD_REQUIRED_FIELDS,
+  TWITTER_PROPERTIES,
+} from "./social.js";
 import type {
   AuditSummary,
   AuditTarget,
@@ -7,6 +18,8 @@ import type {
   RobotsAudience,
   RobotsSignal,
   Severity,
+  SocialMetadataProperty,
+  SocialMetadataSignal,
   TargetAuditResult,
 } from "./types.js";
 
@@ -264,6 +277,146 @@ function checkRepeatedRobots(findings: Finding[], targetUrl: string, probe: Prob
   }
 }
 
+function auditedSocialProperties(
+  target: AuditTarget,
+  probe: ProbeResult,
+): readonly SocialMetadataProperty[] {
+  const properties = new Set<SocialMetadataProperty>();
+  if (target.expectations.requireOpenGraph === true) {
+    for (const property of OPEN_GRAPH_PROPERTIES) properties.add(property);
+  }
+  if (target.expectations.requireTwitterCard === true) {
+    for (const property of TWITTER_PROPERTIES) properties.add(property);
+    if (firstSocialSignal(probe.signals, "twitter:title") === undefined) {
+      properties.add("og:title");
+    }
+    if (firstSocialSignal(probe.signals, "twitter:description") === undefined) {
+      properties.add("og:description");
+    }
+    if (firstSocialSignal(probe.signals, "twitter:image") === undefined) {
+      properties.add("og:image");
+    }
+  }
+  return [...properties];
+}
+
+function normalizedSocialValues(
+  property: SocialMetadataProperty,
+  signals: readonly SocialMetadataSignal[],
+  baseUrl: string,
+): readonly string[] {
+  return signals
+    .map((signal) => normalizeSocialValue(property, signal.value, baseUrl))
+    .filter((value) => value.length > 0);
+}
+
+function checkRepeatedSocialMetadata(
+  findings: Finding[],
+  target: AuditTarget,
+  probe: ProbeResult,
+): void {
+  for (const property of auditedSocialProperties(target, probe)) {
+    // Open Graph explicitly permits multiple images and gives the first one precedence.
+    if (property === "og:image") continue;
+    const values = normalizedSocialValues(
+      property,
+      socialSignals(probe.signals, property),
+      probe.finalUrl,
+    );
+    if (values.length < 2) continue;
+
+    const distinct = new Set(values);
+    const conflicting = distinct.size > 1;
+    addFinding(findings, target.url, {
+      code: conflicting ? "conflicting-social-metadata" : "duplicate-social-metadata",
+      severity: "warning",
+      message: conflicting
+        ? `${probe.agent.label} received conflicting ${property} values.`
+        : `${probe.agent.label} received duplicate ${property} values.`,
+      agent: probe.agent.key,
+      evidence: {
+        property,
+        count: values.length,
+        distinctValues: distinct.size,
+        values: [...distinct].join(" | "),
+      },
+    });
+  }
+}
+
+function checkSocialUrls(findings: Finding[], target: AuditTarget, probe: ProbeResult): void {
+  const candidates = new Set<SocialMetadataSignal>();
+  if (target.expectations.requireOpenGraph === true) {
+    for (const signal of socialSignals(probe.signals, "og:url")) candidates.add(signal);
+    for (const signal of socialSignals(probe.signals, "og:image")) candidates.add(signal);
+  }
+  if (target.expectations.requireTwitterCard === true) {
+    const image = effectiveTwitterCardSignal(probe.signals, "image");
+    if (image !== undefined) candidates.add(image);
+  }
+
+  for (const signal of candidates) {
+    if (signal.value.trim().length === 0 || isAbsoluteHttpSocialUrl(signal.value)) continue;
+    addFinding(findings, target.url, {
+      code: "invalid-social-metadata-url",
+      severity: "warning",
+      message: `${probe.agent.label} received a non-absolute HTTP(S) ${signal.property} URL.`,
+      agent: probe.agent.key,
+      evidence: { property: signal.property, value: signal.value },
+    });
+  }
+}
+
+function checkRequiredSocialMetadata(
+  findings: Finding[],
+  target: AuditTarget,
+  probe: ProbeResult,
+): void {
+  if (probe.completion !== "complete") return;
+
+  if (target.expectations.requireOpenGraph === true) {
+    const missing = OPEN_GRAPH_REQUIRED_PROPERTIES.filter(
+      (property) => firstSocialSignal(probe.signals, property) === undefined,
+    );
+    if (missing.length > 0) {
+      addFinding(findings, target.url, {
+        code: "missing-open-graph-metadata",
+        severity: "warning",
+        message: `${probe.agent.label} received an incomplete Open Graph metadata set.`,
+        agent: probe.agent.key,
+        evidence: { fields: missing.join(", ") },
+      });
+    }
+  }
+
+  if (target.expectations.requireTwitterCard === true) {
+    const missing = TWITTER_CARD_REQUIRED_FIELDS.filter(
+      (field) => effectiveTwitterCardSignal(probe.signals, field) === undefined,
+    );
+    if (missing.length > 0) {
+      addFinding(findings, target.url, {
+        code: "missing-twitter-card-metadata",
+        severity: "warning",
+        message: `${probe.agent.label} received an incomplete Twitter Card metadata set.`,
+        agent: probe.agent.key,
+        evidence: { fields: missing.join(", ") },
+      });
+    }
+  }
+}
+
+function checkSocialMetadata(findings: Finding[], target: AuditTarget, probe: ProbeResult): void {
+  if (
+    target.expectations.requireOpenGraph !== true &&
+    target.expectations.requireTwitterCard !== true
+  ) {
+    return;
+  }
+  checkRequiredSocialMetadata(findings, target, probe);
+  checkRepeatedSocialMetadata(findings, target, probe);
+  checkSocialUrls(findings, target, probe);
+}
+
 function criticalArrivalMs(target: AuditTarget, probe: ProbeResult): number | undefined {
   const marks: number[] = [];
   const { expectations } = target;
@@ -299,6 +452,20 @@ function criticalArrivalMs(target: AuditTarget, probe: ProbeResult): number | un
   ) {
     marks.push(probe.signals.firstMainText?.atMs ?? 0);
   }
+  if (expectations.requireOpenGraph === true) {
+    const signals = OPEN_GRAPH_REQUIRED_PROPERTIES.map((property) =>
+      firstSocialSignal(probe.signals, property),
+    );
+    if (!signals.every((signal) => signal !== undefined)) return undefined;
+    marks.push(...signals.map((signal) => signal.atMs));
+  }
+  if (expectations.requireTwitterCard === true) {
+    const signals = TWITTER_CARD_REQUIRED_FIELDS.map((field) =>
+      effectiveTwitterCardSignal(probe.signals, field),
+    );
+    if (!signals.every((signal) => signal !== undefined)) return undefined;
+    marks.push(...signals.map((signal) => signal.atMs));
+  }
 
   return marks.length === 0 ? undefined : Math.max(...marks);
 }
@@ -365,7 +532,7 @@ function checkRequiredSignals(findings: Finding[], target: AuditTarget, probe: P
   }
 }
 
-function checkHeadRequirements(findings: Finding[], targetUrl: string, probe: ProbeResult): void {
+function checkHeadRequirements(findings: Finding[], target: AuditTarget, probe: ProbeResult): void {
   if (!probe.agent.requiresHeadMetadata) {
     return;
   }
@@ -384,12 +551,17 @@ function checkHeadRequirements(findings: Finding[], targetUrl: string, probe: Pr
   if (effectiveRobotsSignals(probe).some((signal) => signal.location === "body")) {
     bodyFields.add("robots");
   }
+  for (const property of auditedSocialProperties(target, probe)) {
+    if (socialSignals(probe.signals, property).some((signal) => signal.location === "body")) {
+      bodyFields.add(property);
+    }
+  }
 
   if (bodyFields.size === 0) {
     return;
   }
 
-  addFinding(findings, targetUrl, {
+  addFinding(findings, target.url, {
     code: "head-metadata-in-body",
     severity: "error",
     message: `${probe.agent.label} requires head metadata but received ${[...bodyFields].join(
@@ -440,9 +612,31 @@ function agentValueSummary(
   return probes.map((probe) => `${probe.agent.key}=${valueFor(probe)}`).join("; ");
 }
 
+function openGraphValue(probe: ProbeResult): string {
+  return OPEN_GRAPH_PROPERTIES.map((property) => {
+    const values = [
+      ...new Set(
+        normalizedSocialValues(property, socialSignals(probe.signals, property), probe.finalUrl),
+      ),
+    ];
+    return `${property}=${values.join(" | ") || "<missing>"}`;
+  }).join(", ");
+}
+
+function twitterCardValue(probe: ProbeResult): string {
+  return TWITTER_CARD_REQUIRED_FIELDS.map((field) => {
+    const signal = effectiveTwitterCardSignal(probe.signals, field);
+    const value =
+      signal === undefined
+        ? "<missing>"
+        : normalizeSocialValue(signal.property, signal.value, probe.finalUrl);
+    return `${field}=${value || "<missing>"}`;
+  }).join(", ");
+}
+
 function checkAgentDrift(
   findings: Finding[],
-  targetUrl: string,
+  target: AuditTarget,
   probes: readonly ProbeResult[],
 ): void {
   const complete = probes.filter((probe) => probe.completion === "complete");
@@ -450,7 +644,7 @@ function checkAgentDrift(
     return;
   }
 
-  const comparisons: readonly {
+  const comparisons: {
     readonly field: string;
     readonly valueFor: (probe: ProbeResult) => string;
   }[] = [
@@ -472,6 +666,12 @@ function checkAgentDrift(
       valueFor: effectiveRobotsValue,
     },
   ];
+  if (target.expectations.requireOpenGraph === true) {
+    comparisons.push({ field: "open-graph", valueFor: openGraphValue });
+  }
+  if (target.expectations.requireTwitterCard === true) {
+    comparisons.push({ field: "twitter-card", valueFor: twitterCardValue });
+  }
 
   for (const comparison of comparisons) {
     const values = complete.map(comparison.valueFor);
@@ -479,7 +679,7 @@ function checkAgentDrift(
       continue;
     }
 
-    addFinding(findings, targetUrl, {
+    addFinding(findings, target.url, {
       code: `agent-${comparison.field}-drift`,
       severity: "warning",
       message: `Crawler profiles received different ${comparison.field.replace("-", " ")} values.`,
@@ -556,6 +756,7 @@ export function analyzeTarget(
     checkRepeatedMetadata(findings, target.url, probe, "description", probe.signals.descriptions);
     checkRepeatedMetadata(findings, target.url, probe, "canonical", probe.signals.canonicals);
     checkRepeatedRobots(findings, target.url, probe);
+    checkSocialMetadata(findings, target, probe);
 
     const invalidJsonLd = probe.signals.jsonLd.filter((signal) => signal.valid === false);
     if (probe.completion === "complete" && invalidJsonLd.length > 0) {
@@ -587,11 +788,11 @@ export function analyzeTarget(
       });
     }
 
-    checkHeadRequirements(findings, target.url, probe);
+    checkHeadRequirements(findings, target, probe);
     checkTimings(findings, target, probe);
   }
 
-  checkAgentDrift(findings, target.url, probes);
+  checkAgentDrift(findings, target, probes);
 
   return findings;
 }

package/src/audit.ts

@@ -1,7 +1,15 @@
 import { analyzeTarget, summarizeAudit } from "./analyze.js";
 import { probeUrl } from "./http-probe.js";
 import { redactAudit } from "./redact.js";
-import type { AuditResult, ProbeOptions, SsrWireConfig, TargetAuditResult } from "./types.js";
+import { analyzeStability } from "./stability.js";
+import type {
+  AuditResult,
+  Finding,
+  ProbeOptions,
+  ProbeResult,
+  SsrWireConfig,
+  TargetAuditResult,
+} from "./types.js";
 import { VERSION } from "./version.js";
 
 const DEFAULT_CONCURRENCY = 4;
@@ -12,6 +20,16 @@ interface ProbeTask {
   readonly options: ProbeOptions;
 }
 
+interface ProbeLane {
+  readonly task: ProbeTask;
+  readonly probes: readonly ProbeResult[];
+}
+
+interface SampleFinding {
+  readonly sample: number;
+  readonly finding: Finding;
+}
+
 async function runPool<T, R>(
   inputs: readonly T[],
   limit: number,
@@ -37,8 +55,75 @@ async function runPool<T, R>(
   return results;
 }
 
+function repeatCount(value: number | undefined): number {
+  const repeat = value ?? 1;
+  if (!Number.isInteger(repeat) || repeat < 1 || repeat > 10) {
+    throw new RangeError("repeat must be an integer between 1 and 10.");
+  }
+  return repeat;
+}
+
+function mergeEvidence(
+  sampled: readonly SampleFinding[],
+  repeat: number,
+): Readonly<Record<string, string | number | boolean>> {
+  const merged: Record<string, string | number | boolean> & {
+    occurrences?: number;
+    sampleNumbers?: string;
+    totalSamples?: number;
+  } = {};
+  const keys = [
+    ...new Set(sampled.flatMap(({ finding }) => Object.keys(finding.evidence ?? {}))),
+  ].sort();
+
+  for (const key of keys) {
+    const values = sampled.flatMap(({ finding }) => {
+      const value = finding.evidence?.[key];
+      return value === undefined ? [] : [value];
+    });
+    const unique = [
+      ...new Map(values.map((value) => [`${typeof value}:${String(value)}`, value])).values(),
+    ];
+    const first = unique[0];
+    if (first !== undefined) {
+      merged[key] = unique.length === 1 ? first : unique.map(String).join(" | ");
+    }
+  }
+
+  merged.sampleNumbers = [...new Set(sampled.map((item) => item.sample))]
+    .sort((a, b) => a - b)
+    .join(", ");
+  merged.occurrences = sampled.length;
+  merged.totalSamples = repeat;
+  return merged;
+}
+
+function coalesceFindings(sampled: readonly SampleFinding[], repeat: number): readonly Finding[] {
+  const groups = new Map<string, SampleFinding[]>();
+  for (const item of sampled) {
+    const { finding } = item;
+    const key = JSON.stringify([
+      finding.code,
+      finding.severity,
+      finding.message,
+      finding.url,
+      finding.agent ?? "",
+    ]);
+    const group = groups.get(key) ?? [];
+    group.push(item);
+    groups.set(key, group);
+  }
+
+  return [...groups.values()].map((group) => {
+    const first = group[0]?.finding;
+    if (first === undefined) throw new Error("Cannot coalesce an empty finding group.");
+    return { ...first, evidence: mergeEvidence(group, repeat) };
+  });
+}
+
 export async function runAudit(config: SsrWireConfig): Promise<AuditResult> {
   const started = performance.now();
+  const repeat = repeatCount(config.repeat);
   const tasks: ProbeTask[] = [];
 
   for (const [targetIndex, target] of config.targets.entries()) {
@@ -60,21 +145,43 @@ export async function runAudit(config: SsrWireConfig): Promise<AuditResult> {
   }
 
   const secrets = Object.values(config.headers);
-  const probes = await runPool(tasks, DEFAULT_CONCURRENCY, async (task) => {
-    const probe = await probeUrl(task.options);
-    return { task, probe };
+  const lanes = await runPool<ProbeTask, ProbeLane>(tasks, DEFAULT_CONCURRENCY, async (task) => {
+    const probes: ProbeResult[] = [];
+    for (let sample = 1; sample <= repeat; sample += 1) {
+      const probe = await probeUrl(task.options);
+      probes.push(repeat === 1 ? probe : { ...probe, sample });
+    }
+    return { task, probes };
   });
 
   const results: TargetAuditResult[] = config.targets.map((target, targetIndex) => {
-    const targetProbes = probes
-      .filter((item) => item.task.targetIndex === targetIndex)
+    const targetProbes = lanes
+      .filter((lane) => lane.task.targetIndex === targetIndex)
       .sort((a, b) => a.task.agentIndex - b.task.agentIndex)
-      .map((item) => item.probe);
+      .flatMap((lane) => lane.probes);
+
+    if (repeat === 1) {
+      return {
+        target,
+        probes: targetProbes,
+        findings: analyzeTarget(target, targetProbes),
+      };
+    }
+
+    const sampledFindings: SampleFinding[] = [];
+    for (let sample = 1; sample <= repeat; sample += 1) {
+      const sampleProbes = targetProbes.filter((probe) => probe.sample === sample);
+      sampledFindings.push(
+        ...analyzeTarget(target, sampleProbes).map((finding) => ({ sample, finding })),
+      );
+    }
+    const stability = analyzeStability(target, targetProbes);
 
     return {
       target,
       probes: targetProbes,
-      findings: analyzeTarget(target, targetProbes),
+      findings: [...coalesceFindings(sampledFindings, repeat), ...stability.findings],
+      stability: stability.stability,
     };
   });
 
@@ -82,6 +189,7 @@ export async function runAudit(config: SsrWireConfig): Promise<AuditResult> {
     version: VERSION,
     generatedAt: new Date().toISOString(),
     durationMs: Math.round(performance.now() - started),
+    ...(repeat === 1 ? {} : { repeat }),
     results,
     summary: summarizeAudit(results),
   };

package/src/cli.ts

@@ -14,6 +14,7 @@ interface CliOptions {
   readonly timeout?: number;
   readonly maxBytes?: number;
   readonly maxRedirects?: number;
+  readonly repeat?: number;
   readonly format: ReportFormat;
   readonly output?: string;
   readonly failOn: "error" | "warning" | "never";
@@ -30,6 +31,8 @@ targets:
       canonical: true
       h1: true
       mainText: true
+      openGraph: false
+      twitterCard: false
 
 agents:
   - browser
@@ -40,6 +43,7 @@ agents:
 timeoutMs: 15000
 maxBytes: 10485760
 maxRedirects: 10
+repeat: 1
 
 # Keep preview credentials in environment variables. SSRWire redacts configured values from reports.
 # headers:
@@ -80,6 +84,7 @@ function addCheckOptions(command: Command): Command {
     .option("--timeout <ms>", "request timeout in milliseconds", parseInteger)
     .option("--max-bytes <bytes>", "maximum response bytes", parseInteger)
     .option("--max-redirects <count>", "maximum redirects", parseInteger)
+    .option("--repeat <count>", "sequential samples per URL and agent", parseInteger)
     .option("-f, --format <format>", "terminal, json, or sarif", parseFormat, "terminal")
     .option("-o, --output <path>", "write the report to a file")
     .option("--fail-on <level>", "error, warning, or never", parseFailOn, "error")
@@ -124,6 +129,7 @@ async function check(urls: readonly string[], options: CliOptions): Promise<void
     ...(options.timeout === undefined ? {} : { timeoutMs: options.timeout }),
     ...(options.maxBytes === undefined ? {} : { maxBytes: options.maxBytes }),
     ...(options.maxRedirects === undefined ? {} : { maxRedirects: options.maxRedirects }),
+    ...(options.repeat === undefined ? {} : { repeat: options.repeat }),
   });
   const audit = await runAudit(config);
   const color =
@@ -164,7 +170,7 @@ export async function main(argv: readonly string[] = process.argv): Promise<void
   const program = new Command();
   program
     .name("ssrwire")
-    .description("Inspect streamed SSR HTML and crawler-specific metadata delivery.")
+    .description("Inspect streamed SSR HTML, SEO, and social metadata delivery.")
     .version(VERSION)
     .exitOverride()
     .showHelpAfterError();

package/src/config.ts

@@ -8,6 +8,7 @@ import type { AgentProfile, AuditTarget, SsrWireConfig, TargetExpectations } fro
 const DEFAULT_TIMEOUT_MS = 15_000;
 const DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
 const DEFAULT_MAX_REDIRECTS = 10;
+const DEFAULT_REPEAT = 1;
 const DEFAULT_AGENTS = ["browser", "googlebot", "bingbot", "twitterbot"] as const;
 const DEFAULT_CONFIG_FILES = [
   "ssrwire.config.yml",
@@ -22,6 +23,8 @@ const requireSchema = z
     canonical: z.boolean().optional(),
     h1: z.boolean().optional(),
     mainText: z.boolean().optional(),
+    openGraph: z.boolean().optional(),
+    twitterCard: z.boolean().optional(),
   })
   .strict();
 
@@ -66,6 +69,7 @@ const fileConfigSchema = z
       .max(50 * 1024 * 1024)
       .optional(),
     maxRedirects: z.number().int().min(0).max(20).optional(),
+    repeat: z.number().int().min(1).max(10).optional(),
   })
   .strict();
 
@@ -79,6 +83,7 @@ export interface LoadConfigOptions {
   readonly timeoutMs?: number;
   readonly maxBytes?: number;
   readonly maxRedirects?: number;
+  readonly repeat?: number;
   readonly cwd?: string;
 }
 
@@ -126,6 +131,8 @@ function normalizeTarget(value: string | z.infer<typeof targetObjectSchema>): Au
     requireCanonical: required?.canonical ?? true,
     requireH1: required?.h1 ?? true,
     requireMainText: required?.mainText ?? true,
+    requireOpenGraph: required?.openGraph ?? false,
+    requireTwitterCard: required?.twitterCard ?? false,
     ...(item.maxFirstByteMs === undefined ? {} : { maxFirstByteMs: item.maxFirstByteMs }),
     ...(item.maxCriticalMs === undefined ? {} : { maxCriticalMs: item.maxCriticalMs }),
   };
@@ -291,6 +298,7 @@ export async function loadConfig(options: LoadConfigOptions = {}): Promise<SsrWi
   const timeoutMs = options.timeoutMs ?? file.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const maxBytes = options.maxBytes ?? file.maxBytes ?? DEFAULT_MAX_BYTES;
   const maxRedirects = options.maxRedirects ?? file.maxRedirects ?? DEFAULT_MAX_REDIRECTS;
+  const repeat = options.repeat ?? file.repeat ?? DEFAULT_REPEAT;
 
   if (!Number.isInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > 120_000) {
     throw new ConfigError("timeoutMs must be an integer between 100 and 120000.");
@@ -301,6 +309,9 @@ export async function loadConfig(options: LoadConfigOptions = {}): Promise<SsrWi
   if (!Number.isInteger(maxRedirects) || maxRedirects < 0 || maxRedirects > 20) {
     throw new ConfigError("maxRedirects must be an integer between 0 and 20.");
   }
+  if (!Number.isInteger(repeat) || repeat < 1 || repeat > 10) {
+    throw new ConfigError("repeat must be an integer between 1 and 10.");
+  }
 
   return {
     targets,
@@ -309,5 +320,6 @@ export async function loadConfig(options: LoadConfigOptions = {}): Promise<SsrWi
     timeoutMs,
     maxBytes,
     maxRedirects,
+    repeat,
   };
 }

package/src/http-probe.ts

@@ -55,6 +55,7 @@ function emptySignals(): DocumentSignals {
     descriptions: [],
     canonicals: [],
     robots: [],
+    socialMetadata: [],
     h1s: [],
     jsonLd: [],
   };
@@ -91,6 +92,9 @@ function redactSignals(signals: DocumentSignals, redaction: RedactionPlan): Docu
     descriptions: signals.descriptions.map(element),
     canonicals: signals.canonicals.map(element),
     robots: signals.robots.map(element),
+    ...(signals.socialMetadata === undefined
+      ? {}
+      : { socialMetadata: signals.socialMetadata.map(element) }),
     h1s: signals.h1s.map(element),
     ...(signals.firstMainText === undefined
       ? {}

package/src/index.ts

@@ -8,6 +8,7 @@ export { renderJson, renderReport, renderSarif, renderTerminal } from "./reporte
 export { createStreamInspector } from "./stream-parser.js";
 export type {
   AgentProfile,
+  AgentStability,
   AuditResult,
   AuditSummary,
   AuditTarget,
@@ -26,9 +27,14 @@ export type {
   RobotsAudience,
   RobotsSignal,
   Severity,
+  SocialMetadataProperty,
+  SocialMetadataSignal,
   SsrWireConfig,
+  StabilityTimings,
+  StabilityVariants,
   TargetAuditResult,
   TargetExpectations,
   TimingMark,
+  TimingStats,
 } from "./types.js";
 export { VERSION } from "./version.js";