feat(page-context): collect page-type signals (jsonLdType, ogType, lang)

Add an optional pageTypeSignals field to page-context collection, gated behind the includePageTypeSignals feature setting (off by default). It extracts schema.org JSON-LD @type, Open Graph og:type, and the declared page language, riding the existing collectionResult message so consumers (e.g. Duck.ai sidebar shortcuts) get cheap page-type hints with no extra round-trip and no LLM.

- Export extractPageTypeSignals(document) for unit testing (mirrors domToMarkdown); JSON-LD parsed defensively (malformed/oversized skipped), @type collected as string or array and from @graph, deduped, casing preserved, capped.
- Add jasmine unit specs.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: anpete

injected/src/features/page-context.js

@@ -211,6 +211,104 @@ function getLinkText(node, children, settings) {
     return href ? `[${trimmedContent}](${href})` : collapseWhitespace(children);
 }
 
+/**
+ * Extract cheap, normalized page-type signals from a document: schema.org JSON-LD `@type`,
+ * Open Graph `og:type`, and the declared page language. Every field is best-effort and is empty
+ * or null when the page doesn't expose it. Domain is intentionally omitted; consumers derive it
+ * from the page URL that already accompanies the collected content.
+ * @param {Document} document
+ * @param {{ maxTypes?: number, maxBlockLength?: number }} [options]
+ * @returns {{ jsonLdType: string[], ogType: string | null, lang: string }}
+ */
+export function extractPageTypeSignals(document, { maxTypes = 10, maxBlockLength = 100000 } = {}) {
+    return {
+        jsonLdType: extractJsonLdTypes(document, maxTypes, maxBlockLength),
+        ogType: extractOgType(document),
+        lang: extractLang(document),
+    };
+}
+
+/**
+ * Collect deduped schema.org `@type` values from every JSON-LD block, preserving casing. Handles
+ * `@type` as a string or array and entries nested under `@graph`. Malformed and oversized blocks
+ * are skipped so a bad block never fails the whole collection.
+ * @param {Document} document
+ * @param {number} maxTypes
+ * @param {number} maxBlockLength
+ * @returns {string[]}
+ */
+function extractJsonLdTypes(document, maxTypes, maxBlockLength) {
+    /** @type {string[]} */
+    const types = [];
+    const seen = new Set();
+    /** @param {unknown} value */
+    const add = (value) => {
+        if (typeof value !== 'string') return;
+        const type = value.trim();
+        if (!type || seen.has(type)) return;
+        seen.add(type);
+        types.push(type);
+    };
+
+    const blocks = document.querySelectorAll('script[type="application/ld+json"]');
+    for (const block of blocks) {
+        if (types.length >= maxTypes) break;
+        const text = block.textContent || '';
+        if (!text || text.length > maxBlockLength) continue;
+        let data;
+        try {
+            data = JSON.parse(text);
+        } catch (e) {
+            continue;
+        }
+        collectJsonLdTypes(data, add);
+    }
+
+    return types.slice(0, maxTypes);
+}
+
+/**
+ * Walk a parsed JSON-LD value (object, array, or `@graph` container) and report each `@type`.
+ * @param {unknown} node
+ * @param {(value: unknown) => void} add
+ */
+function collectJsonLdTypes(node, add) {
+    if (Array.isArray(node)) {
+        for (const item of node) collectJsonLdTypes(item, add);
+        return;
+    }
+    if (!node || typeof node !== 'object') return;
+    const obj = /** @type {Record<string, unknown>} */ (node);
+    const type = obj['@type'];
+    if (Array.isArray(type)) {
+        for (const value of type) add(value);
+    } else if (type != null) {
+        add(type);
+    }
+    if (obj['@graph']) {
+        collectJsonLdTypes(obj['@graph'], add);
+    }
+}
+
+/**
+ * @param {Document} document
+ * @returns {string | null}
+ */
+function extractOgType(document) {
+    const meta = document.querySelector('meta[property="og:type"]');
+    const content = meta?.getAttribute('content');
+    const trimmed = typeof content === 'string' ? content.trim() : '';
+    return trimmed || null;
+}
+
+/**
+ * @param {Document} document
+ * @returns {string}
+ */
+function extractLang(document) {
+    return (document.documentElement?.getAttribute('lang') || '').trim();
+}
+
 export default class PageContext extends ContentFeature {
     /** @type {any} */
     #cachedContent = undefined;
@@ -492,6 +590,9 @@ export default class PageContext extends ContentFeature {
         if (this.getFeatureSettingEnabled('includeImages', 'disabled')) {
             content.images = this.getImages();
         }
+        if (this.getFeatureSettingEnabled('includePageTypeSignals', 'disabled')) {
+            content.pageTypeSignals = this.getPageTypeSignals();
+        }
 
         // Cache the result - setter handles timestamp and observer
         // Note: We only cache if content exists. Consider caching empty content too
@@ -620,6 +721,13 @@ export default class PageContext extends ContentFeature {
         return links;
     }
 
+    getPageTypeSignals() {
+        return extractPageTypeSignals(document, {
+            maxTypes: this.getFeatureSetting('maxPageTypeSignals') || 10,
+            maxBlockLength: this.getFeatureSetting('maxJsonLdBlockLength') || 100000,
+        });
+    }
+
     getImages() {
         const images = [];
         const imgSelector = this.getFeatureSetting('imgSelector') || 'img';

injected/unit-test/page-context-signals.spec.js

@@ -0,0 +1,93 @@
+import { JSDOM } from 'jsdom';
+import { extractPageTypeSignals } from '../src/features/page-context.js';
+
+/**
+ * @param {string} html - full document HTML to parse.
+ */
+function signalsFor(html) {
+    const dom = new JSDOM(html);
+    return extractPageTypeSignals(dom.window.document);
+}
+
+function scriptLd(obj) {
+    return '<script type="application/ld+json">' + JSON.stringify(obj) + '</script>';
+}
+
+function pageWithHead(headHtml) {
+    return `<!DOCTYPE html><html><head>${headHtml}</head><body></body></html>`;
+}
+
+describe('page-context.js - extractPageTypeSignals', () => {
+    it('returns empty signals for a bare page', () => {
+        const signals = signalsFor('<!DOCTYPE html><html><head></head><body></body></html>');
+        expect(signals).toEqual({ jsonLdType: [], ogType: null, lang: '' });
+    });
+
+    it('reads and trims og:type', () => {
+        const signals = signalsFor(pageWithHead('<meta property="og:type" content=" video.other ">'));
+        expect(signals.ogType).toBe('video.other');
+    });
+
+    it('returns null og:type when the meta tag is absent', () => {
+        expect(signalsFor(pageWithHead('')).ogType).toBe(null);
+    });
+
+    it('reads the declared page language', () => {
+        const signals = signalsFor('<!DOCTYPE html><html lang="en-US"><head></head><body></body></html>');
+        expect(signals.lang).toBe('en-US');
+    });
+
+    it('reads a string @type from JSON-LD', () => {
+        expect(signalsFor(pageWithHead(scriptLd({ '@type': 'Recipe' }))).jsonLdType).toEqual(['Recipe']);
+    });
+
+    it('reads an array @type from JSON-LD', () => {
+        expect(signalsFor(pageWithHead(scriptLd({ '@type': ['Recipe', 'NewsArticle'] }))).jsonLdType).toEqual(['Recipe', 'NewsArticle']);
+    });
+
+    it('walks @graph entries', () => {
+        const head = scriptLd({ '@graph': [{ '@type': 'Product' }, { '@type': 'Offer' }] });
+        expect(signalsFor(pageWithHead(head)).jsonLdType).toEqual(['Product', 'Offer']);
+    });
+
+    it('dedupes across multiple blocks and preserves schema.org casing', () => {
+        const head = scriptLd({ '@type': 'Recipe' }) + scriptLd({ '@type': ['Recipe', 'VideoObject'] });
+        expect(signalsFor(pageWithHead(head)).jsonLdType).toEqual(['Recipe', 'VideoObject']);
+    });
+
+    it('skips malformed JSON-LD blocks but keeps valid ones', () => {
+        const head = '<script type="application/ld+json">{ not valid json </script>' + scriptLd({ '@type': 'Article' });
+        expect(signalsFor(pageWithHead(head)).jsonLdType).toEqual(['Article']);
+    });
+
+    it('ignores non-string @type values', () => {
+        expect(signalsFor(pageWithHead(scriptLd({ '@type': ['Recipe', 123, null] }))).jsonLdType).toEqual(['Recipe']);
+    });
+
+    it('caps the number of collected types', () => {
+        const many = Array.from({ length: 20 }, (_, i) => ({ '@type': 'T' + i }));
+        const dom = new JSDOM(pageWithHead(scriptLd(many)));
+        const signals = extractPageTypeSignals(dom.window.document, { maxTypes: 3 });
+        expect(signals.jsonLdType).toEqual(['T0', 'T1', 'T2']);
+    });
+
+    it('skips oversized JSON-LD blocks', () => {
+        const big = { '@type': 'Recipe', padding: 'x'.repeat(50) };
+        const dom = new JSDOM(pageWithHead(scriptLd(big)));
+        const signals = extractPageTypeSignals(dom.window.document, { maxBlockLength: 10 });
+        expect(signals.jsonLdType).toEqual([]);
+    });
+
+    it('collects all three signals from a realistic page (recipe with embedded video)', () => {
+        const head =
+            '<meta property="og:type" content="article">' +
+            scriptLd({ '@type': ['Recipe', 'NewsArticle'] }) +
+            scriptLd({ '@type': 'VideoObject' });
+        const dom = new JSDOM(`<!DOCTYPE html><html lang="en"><head>${head}</head><body></body></html>`);
+        expect(extractPageTypeSignals(dom.window.document)).toEqual({
+            jsonLdType: ['Recipe', 'NewsArticle', 'VideoObject'],
+            ogType: 'article',
+            lang: 'en',
+        });
+    });
+});