lighthouse 13.5.0-dev.20261007 → 13.5.0-dev.20261009

package/third-party/ard/README.md

@@ -5,23 +5,32 @@ This is a JavaScript port of the Agentic Resource Discovery (ARD) Conformance Te
 The original Python script is located in the `ards-project/ard-spec` repository:
 - **Upstream Repository**: https://github.com/ards-project/ard-spec
 - **Source Script**: `conformance/bin/conformance-test`
-- **Schema**: `spec/schemas/ai-catalog.schema.json`
+- **Schema**: `spec/schemas/ard-entry.schema.json` (`$defs/ArdManifest` and `$defs/ArdEntry`)
 - **Pinned Commit SHA**: `b76f235a8f461876ad4f1e77abd0eb0eb302b48d`
+- **Reviewed Upstream Files** (SHA-256 of the upstream content the port was last verified against; maintained by `yarn update:ard-spec --ack-port`, do not edit by hand):
+  - `conformance/bin/conformance-test`: `ac2f3cae1c4ac75261fe45786a117aaad275322c92b74110529ad03a794275b4`
+  - `spec/ard.md`: `6deb2cc58216fb279569d8ff61bd4595ccdf6ceaeef6766a1a1c9f25b6b68a62`
 
 ## Modifications for Lighthouse:
 While the validation rules and test suite maintain 1:1 parity with the reference suite, the following adaptations were made for Lighthouse integration:
-- **Structured Error Return:** `ConformanceTester` stores structured objects (`{ element, message }`) in `errors` and `warnings` instead of formatted ANSI CLI strings.
-- **Precompiled Standalone Validator (`schema-validator.js`):** Uses `build/build-ard-schema.js` (`yarn build-ard-schema`) to precompile `ai-catalog.schema.json` into a pure, standalone JavaScript validator (`schema-validator.js`) ahead of time using `Ajv2020` and `ajv/dist/standalone`. This eliminates runtime dynamic compilation (`new Function()` / `eval()`), preventing Content Security Policy (CSP) `unsafe-eval` violations when running inside Chrome DevTools frontend, avoiding runtime `fs.readFileSync` calls in browser/bundled contexts, and keeping `Ajv` out of the client bundle.
+- **Structured Error Return:** `ConformanceTester` stores structured objects (`{ element, message }`) in `errors`, `warnings` and `infos` instead of formatted ANSI CLI strings. The `[label]` prefix upstream puts on entry messages is reported as `element` instead.
+- **Precompiled Standalone Validator (`schema-validator.js`):** Uses `build/build-ard-schema.js` (`yarn build-ard-schema`) to precompile the `ArdManifest` and `ArdEntry` definitions of `ard-entry.schema.json` into a pure, standalone JavaScript module (`schema-validator.js`) ahead of time using `Ajv2020` and `ajv/dist/standalone`. This eliminates runtime dynamic compilation (`new Function()` / `eval()`), preventing Content Security Policy (CSP) `unsafe-eval` violations when running inside Chrome DevTools frontend, avoiding runtime `fs.readFileSync` calls in browser/bundled contexts, and keeping `Ajv` out of the client bundle.
 - **ESM Format Validation:** Imports `uri` and `date-time` format validators statically from `ajv-formats/dist/formats.js` rather than bundling the full `ajv-formats` dynamic plugin.
+- **Schema Error Messages:** Ajv reports different messages than Python's `jsonschema`. The first error not nested inside a `oneOf`/`anyOf` branch is reported, with `'x' is a required property` phrasing kept for `required` errors.
+- **Non-object Input:** Upstream assumes the manifest root and each entry are JSON objects. The port treats anything else as empty, so it reports errors instead of throwing.
 - **Lighthouse Logger:** Replaced raw `console.log` with `lighthouse-logger`.
 
+Publisher resolution (upstream's `resolve_publisher`, spec §5.1) is implemented by the gatherer in `core/gather/gatherers/agentic/ard.js`, and the resulting legacy-location warning by the `ard-schema` audit. `infos` are not surfaced in the audit.
+
 ## Updating Conformance Script
 
-Upstream schema and conformance test synchronization is checked regularly during dependency upgrades (via `core/scripts/upgrade-deps.sh`) and monitored weekly via CI (`.github/workflows/cron-weekly.yml` with `node core/scripts/update-ard-spec.js --check`).
+`yarn check:ard-spec` (`core/scripts/update-ard-spec.js --check`) compares upstream `main` against what Lighthouse has: the vendored schema must match byte-for-byte, and the hand-ported files must match the **Reviewed Upstream Files** hashes above. It runs weekly in CI (`.github/workflows/cron-weekly.yml`) and during dependency upgrades (`core/scripts/upgrade-deps.sh`). Neither of those can mark upstream changes as handled; only `--ack-port` does.
 
-When upstream changes are detected:
-1. Run `yarn update:ard-spec` to fetch the latest `ai-catalog.schema.json` and bump the pinned commit SHA.
-2. Review the printed diff of `conformance/bin/conformance-test` and adapt `third-party/ard/ard.js` to match any updated validation rules.
-3. Run `yarn build-ard-schema` to regenerate the standalone validator (`schema-validator.js`).
-4. Run `yarn mocha third-party/ard/ard-test.js` to verify test conformance.
+When it reports changes (the `update-ard-port` agent skill walks through this in detail):
+1. Run `yarn update:ard-spec`. This syncs `ard-entry.schema.json` verbatim and prints the upstream `conformance-test` diff. If a hand-ported file changed, it exits 1 **without** bumping the pinned SHA.
+2. Port `conformance/bin/conformance-test` changes into `third-party/ard/ard.js` (keep rules, severities and message text 1:1; see modifications above) and update `third-party/ard/ard-test.js`.
+3. If `spec/ard.md` changed, check §5.1 (Discovery Mechanisms) against `core/gather/gatherers/agentic/ard.js`.
+4. If the schema changed, run `yarn build-ard-schema` to regenerate `schema-validator.js`.
+5. Verify: `yarn mocha third-party/ard/ard-test.js core/test/gather/gatherers/agentic/ard-test.js core/test/audits/agentic/ard-schema-test.js` and `yarn smoke ard ardInvalid`.
+6. Run `yarn update:ard-spec --ack-port` to record the reviewed hashes and bump the pinned SHA. `yarn check:ard-spec` should now pass.
 

package/third-party/ard/ard-test.js

@@ -7,352 +7,269 @@
 /**
  * @fileoverview Unit tests for ARD Schema validation logic.
  * Tests mirror the validation rules from
- * ards-project/ard-spec/conformance/bin/conformance-test (validate_manifest).
+ * ards-project/ard-spec/conformance/bin/conformance-test (validate_manifest, ARD v0.91).
  */
 
 import {ConformanceTester} from './ard.js';
 
+/**
+ * @param {Record<string, any>} overrides
+ */
+function entry(overrides = {}) {
+  return {
+    identifier: 'urn:air:google:search:web-search',
+    displayName: 'Web Search API',
+    type: 'application/mcp-server-card+json',
+    url: 'https://example.com/mcp.json',
+    representativeQueries: ['search web', 'find articles'],
+    ...overrides,
+  };
+}
+
+/**
+ * @param {Array<{message: string}>} list
+ * @param {string} text
+ */
+function has(list, text) {
+  return list.some(i => i.message.includes(text));
+}
+
 describe('ARD Schema validation (ported from ard-spec)', () => {
   /** @type {ConformanceTester} */
   let tester;
-  
+
   beforeEach(() => {
     tester = new ConformanceTester();
   });
 
+  it('fails with Error when manifest is malformed JSON', () => {
+    tester.validate_manifest('{ invalid json', 'test');
+    expect(has(tester.errors, 'Malformed JSON in manifest')).toEqual(true);
+  });
+
   it('fails with Error when manifest root is not an object', () => {
     tester.validate_manifest(JSON.stringify('just a string'), 'test');
-    expect(
-      tester.errors.some(i => i.message.includes('Missing required \'specVersion\' root property'))
-    ).toEqual(true);
+    expect(has(tester.errors, 'ArdManifest validation failed')).toEqual(true);
+    expect(has(tester.errors, 'Missing required \'entries\' array')).toEqual(true);
+
+    tester = new ConformanceTester();
+    tester.validate_manifest('null', 'test');
+    expect(has(tester.errors, 'Missing required \'entries\' array')).toEqual(true);
   });
 
-  it('fails with Error when root is missing specVersion', () => {
-    const manifest = {
-      entries: [],
-    };
-    tester.validate_manifest(JSON.stringify(manifest), 'test');
-    expect(
-      tester.errors.some(i => i.message.includes('Missing required \'specVersion\''))
-    ).toEqual(true);
+  it('passes when specVersion is absent (ARD requires only entries)', () => {
+    const passed = tester.validate_manifest(JSON.stringify({entries: [entry()]}), 'test');
+    expect(passed).toEqual(true);
+    expect(tester.errors).toEqual([]);
+    expect(tester.warnings).toEqual([]);
   });
 
-  it('returns warning when specVersion is unrecognized', () => {
+  it('ignores specVersion and other unrecognized top-level members', () => {
     const manifest = {
       specVersion: '2.0',
-      entries: [
-        {
-          identifier: 'urn:air:google:search:web-search',
-          displayName: 'Web Search',
-          type: 'application/mcp-server-card+json',
-          url: 'https://example.com/api',
-          representativeQueries: ['query 1', 'query 2'],
-        },
-      ],
+      host: {displayName: 'Example'},
+      entries: [entry()],
     };
-    tester.validate_manifest(JSON.stringify(manifest), 'test');
-    expect(
-      tester.warnings.some(
-        i => i.message.includes('Unrecognized \'specVersion\'')
-      )
-    ).toEqual(true);
+    const passed = tester.validate_manifest(JSON.stringify(manifest), 'test');
+    expect(passed).toEqual(true);
+    expect(tester.errors).toEqual([]);
+    expect(tester.warnings).toEqual([]);
   });
 
-  it('fails with Error when root contains deprecated collections field (ADR-0003)', () => {
+  it('warns, but does not fail, when root contains deprecated collections (ADR-0003)', () => {
     const manifest = {
       specVersion: '1.0',
       collections: [],
-      entries: [],
+      entries: [entry()],
     };
-    tester.validate_manifest(JSON.stringify(manifest), 'test');
-    expect(
-      tester.errors.some(
-        i => i.message.includes('Deprecated field check: Found \'collections\'')
-      )
-    ).toEqual(true);
+    const passed = tester.validate_manifest(JSON.stringify(manifest), 'test');
+    expect(passed).toEqual(true);
+    expect(tester.errors).toEqual([]);
+    expect(tester.warnings).toEqual([
+      {
+        element: 'Root',
+        message: expect.stringContaining('Found \'collections\' at root'),
+      },
+    ]);
   });
 
   it('fails with Error when entries is missing or not an array', () => {
-    const manifestMissing = {specVersion: '1.0'};
-    tester.validate_manifest(JSON.stringify(manifestMissing), 'test');
-    expect(
-      tester.errors.some(i => i.message.includes('Missing required \'entries\' array'))
-    ).toEqual(true);
+    tester.validate_manifest(JSON.stringify({specVersion: '1.0'}), 'test');
+    expect(has(tester.errors, 'ArdManifest validation failed: \'entries\' is a required property'))
+      .toEqual(true);
+    expect(has(tester.errors, 'Missing required \'entries\' array')).toEqual(true);
 
     tester = new ConformanceTester();
-    const manifestNotArray = {specVersion: '1.0', entries: 'not-an-array'};
-    tester.validate_manifest(JSON.stringify(manifestNotArray), 'test');
-    expect(
-      tester.errors.some(i => i.message.includes('\'entries\' must be a JSON array'))
-    ).toEqual(true);
+    tester.validate_manifest(JSON.stringify({entries: 'not-an-array'}), 'test');
+    expect(has(tester.errors, '\'entries\' must be a JSON array')).toEqual(true);
   });
 
   it('fails with Error when entry is not a JSON object', () => {
-    const manifest = {
-      specVersion: '1.0',
-      entries: ['not an object'],
-    };
+    tester.validate_manifest(JSON.stringify({entries: ['not an object', null]}), 'test');
+    expect(tester.errors).toContainEqual({
+      element: 'Entry #0',
+      message: expect.stringContaining('ArdEntry validation failed'),
+    });
+    expect(tester.errors).toContainEqual({
+      element: 'Entry #1',
+      message: 'Missing required \'identifier\'.',
+    });
+  });
+
+  it('validates each entry against ArdEntry and labels the error', () => {
+    const manifest = {entries: [entry({identifier: 'http://not-a-urn'})]};
     tester.validate_manifest(JSON.stringify(manifest), 'test');
-    expect(
-      tester.errors.some(i => i.message.includes('Missing required \'identifier\''))
-    ).toEqual(true);
+    expect(tester.errors).toContainEqual({
+      element: 'Root',
+      message: expect.stringMatching(
+        /^ArdManifest validation failed: .* at path 'entries\.0\.identifier'$/),
+    });
+    expect(tester.errors).toContainEqual({
+      element: 'Web Search API',
+      message: expect.stringMatching(/^ArdEntry validation failed: .* at path 'identifier'$/),
+    });
   });
 
   it('fails with Error when entry is missing identifier or has invalid RFC 8141 URN', () => {
-    const manifestMissingId = {
-      specVersion: '1.0',
-      entries: [
-        {displayName: 'Test', type: 'application/ai-catalog+json', url: 'https://example.com'},
-      ],
-    };
-    tester.validate_manifest(JSON.stringify(manifestMissingId), 'test');
-    expect(
-      tester.errors.some(i => i.message.includes('Missing required \'identifier\''))
-    ).toEqual(true);
+    tester.validate_manifest(JSON.stringify({entries: [entry({identifier: undefined})]}), 'test');
+    expect(has(tester.errors, 'Missing required \'identifier\'')).toEqual(true);
 
     tester = new ConformanceTester();
-    const manifestInvalidUrn = {
-      specVersion: '1.0',
-      entries: [
-        {
-          identifier: 'http://not-a-urn',
-          displayName: 'Test',
-          type: 'application/ai-catalog+json',
-          url: 'https://example.com',
-        },
-      ],
-    };
-    tester.validate_manifest(JSON.stringify(manifestInvalidUrn), 'test');
-    expect(
-      tester.errors.some(
-        i => i.message.includes('does not match RFC 8141 URN pattern')
-      )
-    ).toEqual(true);
+    tester.validate_manifest(
+      JSON.stringify({entries: [entry({identifier: 'http://not-a-urn'})]}), 'test');
+    expect(has(tester.errors, 'does not match RFC 8141 URN pattern')).toEqual(true);
   });
 
   it('fails with Error when entry is missing displayName or type', () => {
-    const manifestMissingName = {
-      specVersion: '1.0',
-      entries: [
-        {
-          identifier: 'urn:air:google:test:agent',
-          type: 'application/ai-catalog+json',
-          url: 'https://example.com',
-        },
-      ],
-    };
-    tester.validate_manifest(JSON.stringify(manifestMissingName), 'test');
-    expect(
-      tester.errors.some(
-        i => i.message.includes('Missing required \'displayName\'')
-      )
-    ).toEqual(true);
+    tester.validate_manifest(JSON.stringify({entries: [entry({displayName: undefined})]}), 'test');
+    expect(has(tester.errors, 'Missing required \'displayName\'')).toEqual(true);
 
     tester = new ConformanceTester();
-    const manifestMissingType = {
-      specVersion: '1.0',
-      entries: [
-        {
-          identifier: 'urn:air:google:test:agent',
-          displayName: 'Test Agent',
-          url: 'https://example.com',
-        },
-      ],
-    };
-    tester.validate_manifest(JSON.stringify(manifestMissingType), 'test');
-    expect(
-      tester.errors.some(i => i.message.includes('Missing required \'type\''))
-    ).toEqual(true);
+    tester.validate_manifest(JSON.stringify({entries: [entry({type: undefined})]}), 'test');
+    expect(has(tester.errors, 'Missing required \'type\'')).toEqual(true);
   });
 
-  it('returns warning when entry uses a non-standard media type', () => {
-    const manifest = {
-      specVersion: '1.0',
-      entries: [
-        {
-          identifier: 'urn:air:google:test:agent',
-          displayName: 'Test Agent',
-          type: 'application/custom-unknown+json',
-          url: 'https://example.com',
-          representativeQueries: ['q1', 'q2'],
-        },
-      ],
-    };
-    tester.validate_manifest(JSON.stringify(manifest), 'test');
-    expect(
-      tester.warnings.some(
-        i => i.message.includes('not one of standard discovery types')
-      )
-    ).toEqual(true);
+  describe('media type classification', () => {
+    /**
+     * @param {unknown} type
+     */
+    function classify(type) {
+      tester = new ConformanceTester();
+      tester.validate_manifest(JSON.stringify({entries: [entry({type})]}), 'test');
+      return tester;
+    }
+
+    it('accepts standard types, case-insensitively and with parameter whitespace', () => {
+      for (const type of [
+        'application/ai-catalog+json',
+        'APPLICATION/AI-Catalog+JSON',
+        'text/markdown; profile="urn:air:agent-skills"',
+        'text/markdown;profile="urn:air:agent-skills"',
+      ]) {
+        const result = classify(type);
+        expect(result.warnings).toEqual([]);
+        expect(result.infos).toEqual([]);
+      }
+    });
+
+    it('reports application extension types as info only', () => {
+      const result = classify('application/custom-unknown+json');
+      expect(result.errors).toEqual([]);
+      expect(result.warnings).toEqual([]);
+      expect(has(result.infos, 'is a valid application extension media type')).toEqual(true);
+    });
+
+    it('warns on non-application types that are not standard', () => {
+      const result = classify('text/plain');
+      expect(has(result.warnings,
+        'is not one of standard discovery types: [\'application/ai-catalog+json\'')).toEqual(true);
+    });
+
+    it('warns on the deprecated MCP server media type (ADR-0008)', () => {
+      const result = classify('application/mcp-server+json');
+      expect(has(result.warnings,
+        'was renamed by ADR-0008. Use \'application/mcp-server-card+json\'.')).toEqual(true);
+    });
+
+    it('warns when a standard base type has missing or unrecognized parameters', () => {
+      expect(has(classify('text/markdown').warnings,
+        'missing required parameters: profile="urn:air:agent-skills"')).toEqual(true);
+      expect(has(classify('application/ai-catalog+json; v=1').warnings,
+        'unrecognized parameters: v')).toEqual(true);
+    });
+
+    it('warns on invalid or non-string media types', () => {
+      expect(has(classify('not a media type').warnings,
+        'is not a valid IANA media type')).toEqual(true);
+      expect(has(classify('application/ai-catalog+json; a=1; a=2').warnings,
+        'is not a valid IANA media type')).toEqual(true);
+      expect(has(classify(5).warnings, 'Media type must be a string; got int.')).toEqual(true);
+    });
   });
 
   it('fails with Error when value-or-reference constraint is violated', () => {
-    const manifestBoth = {
-      specVersion: '1.0',
-      entries: [{
-        identifier: 'urn:air:google:test:agent',
-        displayName: 'Test',
-        type: 'application/ai-catalog+json',
-        url: 'https://example.com',
-        data: {foo: 'bar'},
-      }],
-    };
-    tester.validate_manifest(JSON.stringify(manifestBoth), 'test');
-    expect(
-      tester.errors.some(
-        i => i.message.includes('both \'url\' and \'data\' are provided')
-      )
-    ).toEqual(true);
+    tester.validate_manifest(JSON.stringify({entries: [entry({data: {foo: 'bar'}})]}), 'test');
+    expect(has(tester.errors, 'both \'url\' and \'data\' are provided')).toEqual(true);
 
     tester = new ConformanceTester();
-    const manifestNeither = {
-      specVersion: '1.0',
-      entries: [{
-        identifier: 'urn:air:google:test:agent',
-        displayName: 'Test',
-        type: 'application/ai-catalog+json',
-      }],
-    };
-    tester.validate_manifest(JSON.stringify(manifestNeither), 'test');
-    expect(
-      tester.errors.some(
-        i => i.message.includes('neither \'url\' nor \'data\' is provided')
-      )
-    ).toEqual(true);
+    tester.validate_manifest(JSON.stringify({entries: [entry({url: undefined})]}), 'test');
+    expect(has(tester.errors, 'neither \'url\' nor \'data\' is provided')).toEqual(true);
   });
 
   it('validates representativeQueries type and size constraints', () => {
-    const manifestNonArray = {
-      specVersion: '1.0',
-      entries: [{
-        identifier: 'urn:air:google:test:agent',
-        displayName: 'Test',
-        type: 'application/ai-catalog+json',
-        url: 'https://example.com',
-        representativeQueries: 'not an array',
-      }],
-    };
-    tester.validate_manifest(JSON.stringify(manifestNonArray), 'test');
-    expect(
-      tester.errors.some(i => i.message.includes('must be an array of strings'))
-    ).toEqual(true);
+    tester.validate_manifest(
+      JSON.stringify({entries: [entry({representativeQueries: 'not an array'})]}), 'test');
+    expect(has(tester.errors, 'must be an array of strings')).toEqual(true);
 
     tester = new ConformanceTester();
-    const manifestNonString = {
-      specVersion: '1.0',
-      entries: [{
-        identifier: 'urn:air:google:test:agent',
-        displayName: 'Test',
-        type: 'application/ai-catalog+json',
-        url: 'https://example.com',
-        representativeQueries: [123, 456],
-      }],
-    };
-    tester.validate_manifest(JSON.stringify(manifestNonString), 'test');
-    expect(
-      tester.errors.some(i => i.message.includes('is not a string'))
-    ).toEqual(true);
+    tester.validate_manifest(
+      JSON.stringify({entries: [entry({representativeQueries: [123, 456]})]}), 'test');
+    expect(has(tester.errors, 'is not a string')).toEqual(true);
 
     tester = new ConformanceTester();
-    const manifestFewQueries = {
-      specVersion: '1.0',
-      entries: [{
-        identifier: 'urn:air:google:test:agent',
-        displayName: 'Test',
-        type: 'application/ai-catalog+json',
-        url: 'https://example.com',
-        representativeQueries: ['only one query'],
-      }],
-    };
-    tester.validate_manifest(JSON.stringify(manifestFewQueries), 'test');
-    expect(
-      tester.warnings.some(i => i.message.includes('2 to 5 queries are recommended'))
-    ).toEqual(true);
+    tester.validate_manifest(
+      JSON.stringify({entries: [entry({representativeQueries: ['only one query']})]}), 'test');
+    expect(has(tester.warnings, '2 to 5 queries are recommended')).toEqual(true);
 
     tester = new ConformanceTester();
-    const manifestMissingQueries = {
-      specVersion: '1.0',
-      entries: [{
-        identifier: 'urn:air:google:test:agent',
-        displayName: 'Test',
-        type: 'application/ai-catalog+json',
-        url: 'https://example.com',
-      }],
-    };
-    tester.validate_manifest(JSON.stringify(manifestMissingQueries), 'test');
-    expect(
-      tester.warnings.some(i => i.message.includes('Missing \'representativeQueries\''))
-    ).toEqual(true);
+    tester.validate_manifest(
+      JSON.stringify({entries: [entry({representativeQueries: undefined})]}), 'test');
+    expect(tester.errors).toEqual([]);
+    expect(has(tester.warnings, 'No \'representativeQueries\'')).toEqual(true);
   });
 
   it('validates trustManifest constraints', () => {
-    const manifestInvalidTrust = {
-      specVersion: '1.0',
-      entries: [{
-        identifier: 'urn:air:google:test:agent',
-        displayName: 'Test',
-        type: 'application/ai-catalog+json',
-        url: 'https://example.com',
-        trustManifest: 'not-an-object',
-      }],
-    };
-    tester.validate_manifest(JSON.stringify(manifestInvalidTrust), 'test');
-    expect(
-      tester.errors.some(
-        i => i.message.includes('\'trustManifest\' must be a JSON object')
-      )
-    ).toEqual(true);
+    tester.validate_manifest(
+      JSON.stringify({entries: [entry({trustManifest: 'not-an-object'})]}), 'test');
+    expect(has(tester.errors, '\'trustManifest\' must be a JSON object')).toEqual(true);
 
     tester = new ConformanceTester();
-    const manifestMissingIdentity = {
-      specVersion: '1.0',
-      entries: [{
-        identifier: 'urn:air:google:test:agent',
-        displayName: 'Test',
-        type: 'application/ai-catalog+json',
-        url: 'https://example.com',
-        trustManifest: {},
-      }],
-    };
-    tester.validate_manifest(JSON.stringify(manifestMissingIdentity), 'test');
-    expect(
-      tester.errors.some(
-        i => i.message.includes('missing required \'identity\' field')
-      )
-    ).toEqual(true);
+    tester.validate_manifest(JSON.stringify({entries: [entry({trustManifest: {}})]}), 'test');
+    expect(has(tester.errors, 'missing required \'identity\' field')).toEqual(true);
   });
 
   it('passes completely when schema is fully conformant with URL or inline data', () => {
     const validManifestUrl = {
-      specVersion: '1.0',
-      entries: [
-        {
-          identifier: 'urn:air:google:search:web-search',
-          displayName: 'Web Search API',
-          type: 'application/mcp-server-card+json',
-          url: 'https://example.com/mcp.json',
-          representativeQueries: ['search web', 'find articles'],
-          trustManifest: {identity: 'google.com'},
-        },
-      ],
+      entries: [entry({trustManifest: {identity: 'google.com'}})],
     };
-    tester.validate_manifest(JSON.stringify(validManifestUrl), 'test');
-    expect(tester.errors.length).toEqual(0);
+    expect(tester.validate_manifest(JSON.stringify(validManifestUrl), 'test')).toEqual(true);
+    expect(tester.errors).toEqual([]);
+    expect(tester.warnings).toEqual([]);
+    expect(tester.infos).toEqual([]);
 
     tester = new ConformanceTester();
     const validManifestData = {
-      specVersion: '1.0',
       entries: [
-        {
+        entry({
           identifier: 'urn:air:google:tools:math-helper',
           displayName: 'Math Helper',
           type: 'application/agent-card+json',
+          url: undefined,
           data: {functions: ['add', 'subtract']},
-          representativeQueries: ['calculate sum', 'compute subtraction'],
-        },
+        }),
       ],
     };
-    tester.validate_manifest(JSON.stringify(validManifestData), 'test');
-    expect(tester.errors.length).toEqual(0);
+    expect(tester.validate_manifest(JSON.stringify(validManifestData), 'test')).toEqual(true);
+    expect(tester.errors).toEqual([]);
   });
 });

package/third-party/ard/ard.d.ts

@@ -1,3 +1,4 @@
+export type ParsedMediaType = [string, Array<[string, string]>];
 export type ValidationError = {
     element: string;
     message: string;
@@ -13,6 +14,8 @@ export class ConformanceTester {
     errors: ValidationError[];
     /** @type {ValidationError[]} */
     warnings: ValidationError[];
+    /** @type {ValidationError[]} */
+    infos: ValidationError[];
     /**
      * @param {string} message
      * @param {string} [element='Root']
@@ -23,7 +26,15 @@ export class ConformanceTester {
      * @param {string} [element='Root']
      */
     add_warning(message: string, element?: string): void;
-    /** @param {any} manifest_data */
+    /**
+     * @param {string} message
+     * @param {string} [element='Root']
+     */
+    add_info(message: string, element?: string): void;
+    /**
+     * Validate the manifest as an ArdManifest, then every entry as an ArdEntry.
+     * @param {any} manifest_data
+     */
     run_json_schema_validation(manifest_data: any): boolean;
     /**
      * @param {string} raw_content
@@ -31,4 +42,9 @@ export class ConformanceTester {
      */
     validate_manifest(raw_content: string, source_label: string): boolean;
 }
+/**
+ * @param {unknown} media_type
+ * @return {['warning'|'info', string]|null}
+ */
+export function classify_media_type(media_type: unknown): ["warning" | "info", string] | null;
 //# sourceMappingURL=ard.d.ts.map