@tineira/apc-conformance 0.8.0 → 0.9.0

package/dist/hub.d.ts

@@ -0,0 +1,43 @@
+export type StandInHubMode = "ack" | "no_ack" | "redirect" | "error_500";
+export interface StandInPairing {
+    id: string;
+    agent: string;
+    mcp_url: string;
+    app_origin: string;
+    status: "pending" | "paired";
+    /** The code the app sent, raw, until it is typed right; null for an app that sent none. */
+    pairing_code: string | null;
+    attempts: number;
+}
+export interface StandInHubOptions {
+    /** The hub's origin; "https://dock.test" by default. */
+    origin?: string;
+    /** How the hub reaches the app (its `/apc/revoke` and the grant's MCP URL): in process, the app's own handler. Without it the hub calls nobody. */
+    app?: (request: Request) => Promise<Response>;
+    /** Milliseconds since the epoch, for tickets; Date.now by default. */
+    now?: () => number;
+}
+export interface StandInHub {
+    readonly origin: string;
+    /** What the app's server calls the hub with (pass it as the app's fetch, or route the hub's origin to it). */
+    readonly fetch: typeof fetch;
+    /** How the hub answers `/apc/pair`: "ack" (a hub of 0.9) unless a check sets another. */
+    mode: StandInHubMode;
+    /** A new single-use ticket for this agent, as the dock puts on a drag. */
+    ticket(agent: string): string;
+    /** The pairings it holds, pending and paired. */
+    readonly pairings: StandInPairing[];
+    /** Every `/apc/pair` body the app sent, oldest first, whatever the hub answered. */
+    readonly received: Array<Record<string, unknown>>;
+    /** The MCP URL of the agent's latest pairing. */
+    urlOf(agent: string): string | undefined;
+    /** The dock owner approves (with what they typed) or denies a pairing. */
+    decide(pairingId: string, action: "approve" | "deny", code?: unknown): Promise<{
+        ok: boolean;
+        error?: string;
+        attempts_left?: number;
+    }>;
+    /** The pairing code's time ran out: every pending pairing with a code goes, its grant given back. */
+    expire(): Promise<void>;
+}
+export declare function standInHub(options?: StandInHubOptions): StandInHub;

package/dist/hub.js

@@ -0,0 +1,147 @@
+/**
+ * A stand-in for a dock's hub (the Dock profile), for testing an app in process: what `@tineira/apc-conformance`
+ * checks a Dock app against, and what an app's own tests can pair with. It is faithful to the parts of a hub an
+ * app meets, as of APC 0.9:
+ *
+ * - **Tickets**: `ticket(agent)` mints a single-use ticket for an agent, valid `TICKET_TTL_MS`.
+ * - **`POST {hub}/apc/pair`**: checks the body before it spends the ticket (a `pairing_code` present but not a
+ *   code is `invalid_pairing_code`), keeps the code with the pending pairing and answers the acknowledgement
+ *   (`pairing_code: "required"`). An app that sends no code still pairs, as a hub in `when_sent` mode lets it.
+ * - **`POST {hub}/apc/confirm`**: whether it still pairs that agent with that MCP URL.
+ * - **The dock owner's answer** (`decide`): approving a pairing with a code needs that code; wrong ones count, and
+ *   the last of `PAIRING_CODE_MAX_ATTEMPTS` removes the pairing and gives the grant back
+ *   (`POST {app}/apc/revoke`); the right one pairs it and introduces the hub to the app (`initialize` on the
+ *   grant). `expire()` is the pairing code's time running out: every pending pairing with a code goes, its
+ *   grant given back.
+ * - **A broken hub**, for the checks that an app fails closed (`mode`): `"no_ack"` answers a yes without the
+ *   acknowledgement (a hub from before 0.9), `"redirect"` redirects `/apc/pair` to another host that says yes,
+ *   `"error_500"` says yes with HTTP 500.
+ *
+ * It never shows a code: `received` keeps what the app sent, for the checks to compare with what the app showed.
+ */
+import { normalizePairingCode, PAIRING_CODE_ACK, PAIRING_CODE_MAX_ATTEMPTS, pairingCodesMatch, TICKET_TTL_MS } from "@tineira/apc-protocol";
+const randomHex = (bytes) => [...crypto.getRandomValues(new Uint8Array(bytes))].map((b) => b.toString(16).padStart(2, "0")).join("");
+export function standInHub(options = {}) {
+    const origin = options.origin ?? "https://dock.test";
+    const now = options.now ?? Date.now;
+    const did = randomHex(16);
+    const tickets = new Map();
+    const pairings = [];
+    const received = [];
+    const json = (body, status = 200) => Response.json(body, { status });
+    const callApp = async (url, body) => {
+        if (!options.app)
+            return;
+        const response = await options.app(new Request(url, { method: "POST", headers: { "content-type": "application/json", accept: "application/json, text/event-stream" }, body: JSON.stringify(body) }));
+        await response.body?.cancel().catch(() => { });
+    };
+    const giveBack = async (p) => {
+        pairings.splice(pairings.indexOf(p), 1);
+        await callApp(`${p.app_origin}/apc/revoke`, { mcp_url: p.mcp_url });
+    };
+    const live = (ticket, agent) => {
+        const t = typeof ticket === "string" ? tickets.get(ticket) : undefined;
+        return !!t && t.agent === agent && t.expires_at > now();
+    };
+    const pair = (b) => {
+        if (typeof b.ticket !== "string" || typeof b.agent !== "string" || typeof b.mcp_url !== "string")
+            return json({ ok: false, error: "invalid" }, 400);
+        const app = b.app;
+        if (typeof app?.name !== "string" || !app.name || typeof app.origin !== "string")
+            return json({ ok: false, error: "app_not_allowed" }, 400);
+        // The body first: a malformed code leaves the ticket good.
+        const code = b.pairing_code === undefined ? null : normalizePairingCode(b.pairing_code);
+        if (b.pairing_code !== undefined && !code)
+            return json({ ok: false, error: "invalid_pairing_code" }, 400);
+        if (!live(b.ticket, b.agent))
+            return json({ ok: false, error: "ticket_expired" }, 400);
+        tickets.delete(b.ticket);
+        const p = { id: `pr_${randomHex(6)}`, agent: b.agent, mcp_url: b.mcp_url, app_origin: app.origin, status: "pending", pairing_code: code, attempts: 0 };
+        pairings.push(p);
+        return json({ ok: true, pairing_id: p.id, status: "pending", agent: { name: "Agent via dock", icon: null }, ...(code ? { pairing_code: PAIRING_CODE_ACK } : {}) });
+    };
+    const hub = {
+        origin,
+        mode: "ack",
+        pairings,
+        received,
+        ticket(agent) {
+            const ticket = `${did}.${randomHex(16)}`;
+            tickets.set(ticket, { agent, expires_at: now() + TICKET_TTL_MS });
+            return ticket;
+        },
+        urlOf: (agent) => pairings.filter((p) => p.agent === agent).at(-1)?.mcp_url,
+        fetch: (async (input, init) => {
+            const request = input instanceof Request ? input : new Request(input, init);
+            const url = new URL(request.url);
+            if (url.origin !== origin || request.method !== "POST")
+                return json({ ok: false, error: "not_found" }, 404);
+            const body = ((await request.json().catch(() => null)) ?? {});
+            if (url.pathname === "/apc/pair") {
+                received.push(body);
+                if (hub.mode === "redirect") {
+                    // A fetch that refuses redirects (as an app's must) fails; one that follows lands on another host that says yes.
+                    if ((init?.redirect ?? request.redirect) === "error")
+                        throw new TypeError(`redirect from ${request.url} refused`);
+                    const elsewhere = json({ ok: true, pairing_id: "pr_elsewhere", status: "pending", agent: { name: "Agent via dock", icon: null }, pairing_code: PAIRING_CODE_ACK });
+                    Object.defineProperty(elsewhere, "redirected", { value: true });
+                    return elsewhere;
+                }
+                if (hub.mode === "error_500")
+                    return json({ ok: true, pairing_id: "pr_500", status: "pending", agent: { name: "Agent via dock", icon: null }, pairing_code: PAIRING_CODE_ACK }, 500);
+                const answer = pair(body);
+                if (hub.mode === "no_ack" && answer.ok) {
+                    const rest = (await answer.json());
+                    delete rest.pairing_code;
+                    return json(rest);
+                }
+                return answer;
+            }
+            if (url.pathname === "/apc/confirm") {
+                if (!live(body.ticket, body.agent))
+                    return json({ ok: false, error: "ticket_expired" }, 400);
+                const p = pairings.find((x) => x.agent === body.agent && x.mcp_url === body.mcp_url);
+                if (!p)
+                    return json({ ok: false, error: "not_paired" }, 400);
+                tickets.delete(body.ticket);
+                return json({ ok: true, status: p.status, agent: { name: "Agent via dock", icon: null } });
+            }
+            return json({ ok: false, error: "not_found" }, 404);
+        }),
+        async decide(pairingId, action, code) {
+            const p = pairings.find((x) => x.id === pairingId);
+            if (!p)
+                return { ok: false, error: "unknown_pairing" };
+            if (action === "deny") {
+                await giveBack(p);
+                return { ok: true };
+            }
+            if (p.status !== "pending")
+                return { ok: false, error: "invalid_action" };
+            if (p.pairing_code) {
+                if (code === undefined || code === null || code === "")
+                    return { ok: false, error: "pairing_code_required" };
+                const given = normalizePairingCode(code);
+                if (!given)
+                    return { ok: false, error: "invalid_pairing_code" };
+                if (!pairingCodesMatch(p.pairing_code, given)) {
+                    p.attempts++;
+                    if (p.attempts < PAIRING_CODE_MAX_ATTEMPTS)
+                        return { ok: false, error: "wrong_pairing_code", attempts_left: PAIRING_CODE_MAX_ATTEMPTS - p.attempts };
+                    await giveBack(p);
+                    return { ok: false, error: "pairing_code_refused" };
+                }
+                p.pairing_code = null;
+            }
+            p.status = "paired";
+            // The hub introduces itself to the app, as a real one does on approval.
+            await callApp(p.mcp_url, { jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: "apc-hub", title: "Agent via dock", version: "0.9.0" } } });
+            return { ok: true };
+        },
+        async expire() {
+            for (const p of pairings.filter((x) => x.status === "pending" && x.pairing_code))
+                await giveBack(p);
+        },
+    };
+    return hub;
+}

package/dist/index.d.ts

@@ -8,7 +8,11 @@
  * (`GET {origin}/.well-known/apc.json`, through the adapter's `fetch`): its shape, its origin, the
  * standard, and that its profiles and `mcp.path` match what the app serves. Since 0.6 an adapter may
  * also give `page.mobile` (the page on a phone): the suite then checks that every agent is shown in the
- * page, that the bar cannot be collapsed, and that a finger can pin and unpin with no mouse drag.
+ * page, that the bar cannot be collapsed, and that a finger can pin and unpin with no mouse drag. Since 0.9
+ * an app on the Dock profile gives `dock` too: the suite pairs it with a stand-in hub (`standInHub`) and checks
+ * the pairing code (the consent shows one, new each time, and sends that one to the hub; the app keeps no grant
+ * when the hub does not acknowledge the code; wrong codes and the code's time running out give the grant back;
+ * the right code pairs).
  *
  * Framework-free: `apcConformance(app)` returns named checks that throw `ConformanceError`, for any
  * test runner (`for (const c of apcConformance(app)) test(c.name, c.run)` under `node --test`), and
@@ -19,7 +23,9 @@
  * and a revoked grant's answer); the `apc-conformance` command (`cli.ts`) runs them from a terminal.
  */
 import { type ApcProfile, type FocusTarget, type PresenceEvent } from "@tineira/apc-protocol";
+import type { StandInHub } from "./hub.js";
 export { ConformanceError } from "./shared.js";
+export { standInHub, type StandInHub, type StandInHubMode, type StandInHubOptions, type StandInPairing } from "./hub.js";
 export { HttpConformanceUsageError, IN_PROCESS_ONLY, httpConformance, redactGrantUrl, redactSecrets, runHttpConformance, type HttpCheck, type HttpCheckResult, type HttpConformanceOptions, type HttpConformanceReport, } from "./http.js";
 /**
  * One agent's way into the app: the MCP URL its holder calls (the agent itself, or a dock's hub), the
@@ -69,6 +75,26 @@ export interface ApcMobilePage {
     /** The person removes the agent's pin with a finger (the × beside the agent in the bar). False when the page offers no way. */
     unpinByTouch(grantId: string): Promise<boolean>;
 }
+/**
+ * The Dock profile's pairing (APC 0.9), from an app on that profile: required of one that claims 0.9.0 or later.
+ * The app pairs with `hub`, a stand-in from this package (`standInHub({ app })`, whose `app` routes to the app's
+ * handler), which the app's server reaches as its hub.
+ */
+export interface ApcDockAdapter {
+    hub: StandInHub;
+    /**
+     * The person drops an agent the app holds no grant for, with a ticket from `hub.ticket(agent)`: the pairing code
+     * the app's consent shows, as the person sees it (formatted or not), and their Allow on that consent, with what
+     * the app answered the page.
+     */
+    drop(agent: string, ticket: string): Promise<{
+        shown: string;
+        allow(): Promise<{
+            ok: boolean;
+            error?: string;
+        }>;
+    }>;
+}
 /** What the suite needs from an app. */
 export interface ApcAppAdapter {
     /** The app's name, for the report. */
@@ -102,6 +128,8 @@ export interface ApcAppAdapter {
     };
     /** An app that offers both profiles: the `apc_link` checks run too. */
     link?: ApcLinkAdapter;
+    /** The Dock profile's pairing code (APC 0.9): required with `profile: "dock"` of an app that claims 0.9.0 or later. */
+    dock?: ApcDockAdapter;
 }
 export interface ConformanceCheck {
     name: string;

package/dist/index.js

@@ -8,7 +8,11 @@
  * (`GET {origin}/.well-known/apc.json`, through the adapter's `fetch`): its shape, its origin, the
  * standard, and that its profiles and `mcp.path` match what the app serves. Since 0.6 an adapter may
  * also give `page.mobile` (the page on a phone): the suite then checks that every agent is shown in the
- * page, that the bar cannot be collapsed, and that a finger can pin and unpin with no mouse drag.
+ * page, that the bar cannot be collapsed, and that a finger can pin and unpin with no mouse drag. Since 0.9
+ * an app on the Dock profile gives `dock` too: the suite pairs it with a stand-in hub (`standInHub`) and checks
+ * the pairing code (the consent shows one, new each time, and sends that one to the hub; the app keeps no grant
+ * when the hub does not acknowledge the code; wrong codes and the code's time running out give the grant back;
+ * the right code pairs).
  *
  * Framework-free: `apcConformance(app)` returns named checks that throw `ConformanceError`, for any
  * test runner (`for (const c of apcConformance(app)) test(c.name, c.run)` under `node --test`), and
@@ -18,9 +22,10 @@
  * of the suite that HTTP reaches (apc.json, and with a grant's MCP URL the core tools' shapes and timing,
  * and a revoked grant's answer); the `apc-conformance` command (`cli.ts`) runs them from a terminal.
  */
-import { APC_AGENT_CLIENT_META, APC_JSON_MAX_BYTES, APC_JSON_PATH, APC_MOBILE_VIEWPORT, APC_STANDARD_VERSION, APC_LINK_KEY, APC_LINK_TOOL, APC_LINK_TTL_S, CORE_TOOLS, LINK_REFUSED_ERROR, REVOKED_ERROR, REVOKED_HTTP_STATUS, REVOKED_HTTP_STATUS_BEARER, WAIT_CLAIM_GAP_S, canonicalTarget, compareStandard, declaresMcpUrl, isRevokedAnswer, parseApcManifest, } from "@tineira/apc-protocol";
+import { APC_AGENT_CLIENT_META, APC_JSON_MAX_BYTES, APC_JSON_PATH, APC_MOBILE_VIEWPORT, APC_STANDARD_VERSION, APC_LINK_KEY, APC_LINK_TOOL, APC_LINK_TTL_S, CORE_TOOLS, LINK_REFUSED_ERROR, REVOKED_ERROR, REVOKED_HTTP_STATUS, REVOKED_HTTP_STATUS_BEARER, WAIT_CLAIM_GAP_S, canonicalTarget, compareStandard, declaresMcpUrl, isRevokedAnswer, normalizePairingCode, PAIRING_CODE_MAX_ATTEMPTS, parseApcManifest, } from "@tineira/apc-protocol";
 import { ConformanceError, ISO, attentionOf, checkCoreToolList, checkFocusShape, checkView, data, expect, isObject, resultKey, rpcBody, standardSupport, text } from "./shared.js";
 export { ConformanceError } from "./shared.js";
+export { standInHub } from "./hub.js";
 export { HttpConformanceUsageError, IN_PROCESS_ONLY, httpConformance, redactGrantUrl, redactSecrets, runHttpConformance, } from "./http.js";
 /** A grant's credential travels in a header (a bearer token), not in its URL: several grants may share the URL (APC 0.8). */
 const sharesUrl = (conn) => !!conn.headers && Object.keys(conn.headers).some((h) => h.toLowerCase() === "authorization");
@@ -356,9 +361,127 @@ export function apcConformance(app) {
             await Promise.race([waiting, sleep(11_000)]);
         })),
         ...mobileChecks(app, app.page.mobile),
+        ...(app.profile === "dock" ? dockChecks(app, app.dock) : []),
         ...(app.link ? linkChecks(app, app.link) : []),
     ];
 }
+/** What a check of a 0.9 rule says of an app that claims an earlier standard: passed, not checked. */
+const NOT_09 = { note: "not checked: the app's apc.json claims a standard before 0.9.0, which does not have the pairing code" };
+/** The standard an app's apc.json claims, read from the origin of one of its grants. */
+async function claimedStandard(app, conn) {
+    const request = new Request(`${new URL(conn.mcpUrl).origin}${APC_JSON_PATH}`, { headers: { accept: "application/json" } });
+    const response = await (app.fetch ? app.fetch(request) : fetch(request));
+    return (await response.json().catch(() => ({}))).standard;
+}
+/**
+ * The pairing code (APC 0.9), on the Dock profile: the consent shows a well-formed code, new for every consent,
+ * and the app sends that code to the hub; the app keeps no grant unless the hub acknowledges the code with a
+ * plain 200; five wrong codes, or the code's time running out, give the grant back; the right code pairs.
+ */
+function dockChecks(app, dock) {
+    const check = (name, run) => noted(`${app.name} (dock): pairing code: ${name}`, run);
+    let n = 0;
+    /** A new agent's drop, Allowed: what the consent showed, the app's answer, and the pairing the hub got. */
+    const allowNew = async (d) => {
+        const agent = `ag_code_${++n}_${Date.now().toString(36)}`;
+        const drop = await d.drop(agent, d.hub.ticket(agent));
+        const answer = await drop.allow();
+        return { agent, shown: drop.shown, answer, sent: d.hub.received.at(-1), pairing: d.hub.pairings.find((p) => p.agent === agent) };
+    };
+    /** The HTTP status the app gives a grant's MCP URL: 404 once it holds no grant there. */
+    const statusOf = async (mcpUrl) => (await send(app, { mcpUrl, grantId: "" }, "initialize", { protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: "apc-conformance", version: "1" } })).status;
+    /** Whether the app claims 0.9.0 or later, read through a grant made the usual way. */
+    const claims09 = async () => {
+        const claimed = await claimedStandard(app, await app.connect());
+        return typeof claimed === "string" && compareStandard(claimed, "0.9.0") >= 0;
+    };
+    return [
+        check("the dock adapter is given (required of an app that claims 0.9.0 or later on the Dock profile)", async () => {
+            if (dock)
+                return;
+            const claimed = await claimedStandard(app, await app.connect());
+            expect(typeof claimed === "string" && compareStandard(claimed, "0.9.0") < 0, `apc.json claims standard ${String(claimed)}, which requires the pairing code to be checked: give dock in the adapter (ApcDockAdapter: hub, drop)`);
+        }),
+        check("the consent shows a well-formed code, and the app sends that code, raw, to the hub", async () => {
+            if (!dock)
+                return;
+            if (!(await claims09()))
+                return NOT_09;
+            const { shown, answer, sent } = await allowNew(dock);
+            const code = normalizePairingCode(shown);
+            expect(code, `the consent shows ${JSON.stringify(shown)}, not a pairing code (6 characters of Crockford base32)`);
+            expect(answer.ok, `the Allow did not pair: ${answer.error}`);
+            expect(isObject(sent), "the app sent the hub no /apc/pair");
+            expect(sent.pairing_code !== undefined, "the app sent /apc/pair without pairing_code: an app of 0.9 must send the code its consent showed");
+            expect(normalizePairingCode(sent.pairing_code) === sent.pairing_code, `the app sent pairing_code ${JSON.stringify(sent.pairing_code)}: send it raw, 6 characters, no dash`);
+            expect(sent.pairing_code === code, "the app sent the hub another code than the one its consent showed");
+        }),
+        check("every consent shows a new code", async () => {
+            if (!dock)
+                return;
+            if (!(await claims09()))
+                return NOT_09;
+            const a = `ag_two_${++n}`;
+            const b = `ag_two_${++n}`;
+            const first = normalizePairingCode((await dock.drop(a, dock.hub.ticket(a))).shown);
+            const second = normalizePairingCode((await dock.drop(b, dock.hub.ticket(b))).shown);
+            expect(first && second, "a consent shows no pairing code");
+            expect(first !== second, `two consents showed the same code, ${first}`);
+        }),
+        check("a hub that does not acknowledge the code, redirects, or says yes with HTTP 500 holds no grant", async () => {
+            if (!dock)
+                return;
+            if (!(await claims09()))
+                return NOT_09;
+            try {
+                for (const mode of ["no_ack", "redirect", "error_500"]) {
+                    dock.hub.mode = mode;
+                    const { answer, sent } = await allowNew(dock);
+                    expect(!answer.ok, `with a hub that answers ${mode}, the Allow says it paired: the app must refuse it`);
+                    expect(isObject(sent) && typeof sent.mcp_url === "string", `with a hub that answers ${mode}, the app sent no MCP URL to check`);
+                    const status = await statusOf(sent.mcp_url);
+                    expect(status === 404, `with a hub that answers ${mode}, the grant the app made still answers (HTTP ${status}): it must be deleted before the app answers its page`);
+                }
+            }
+            finally {
+                dock.hub.mode = "ack";
+            }
+        }),
+        check(`${PAIRING_CODE_MAX_ATTEMPTS} wrong codes, or the code's time running out, give the grant back`, async () => {
+            if (!dock)
+                return;
+            if (!(await claims09()))
+                return NOT_09;
+            const wrong = await allowNew(dock);
+            expect(wrong.answer.ok && wrong.pairing, `the Allow did not pair: ${wrong.answer.error}`);
+            const code = normalizePairingCode(wrong.shown);
+            const other = code.startsWith("A") ? "BBBBBB" : "AAAAAA";
+            for (let i = 1; i <= PAIRING_CODE_MAX_ATTEMPTS; i++)
+                await dock.hub.decide(wrong.pairing.id, "approve", other);
+            expect(!dock.hub.pairings.includes(wrong.pairing), "the stand-in hub kept a pairing after the last wrong code");
+            const afterWrong = await statusOf(wrong.pairing.mcp_url);
+            expect(afterWrong === 404, `after ${PAIRING_CODE_MAX_ATTEMPTS} wrong codes the hub gave the grant back, and it still answers (HTTP ${afterWrong})`);
+            const late = await allowNew(dock);
+            expect(late.answer.ok && late.pairing, `the Allow did not pair: ${late.answer.error}`);
+            await dock.hub.expire();
+            const afterExpiry = await statusOf(late.pairing.mcp_url);
+            expect(afterExpiry === 404, `the code's time ran out and the hub gave the grant back, and it still answers (HTTP ${afterExpiry})`);
+        }),
+        check("the right code pairs, and the grant answers", async () => {
+            if (!dock)
+                return;
+            if (!(await claims09()))
+                return NOT_09;
+            const { shown, answer, pairing } = await allowNew(dock);
+            expect(answer.ok && pairing, `the Allow did not pair: ${answer.error}`);
+            const decided = await dock.hub.decide(pairing.id, "approve", shown);
+            expect(decided.ok, `the code the consent showed did not approve the pairing: ${decided.error}`);
+            const conn = { mcpUrl: pairing.mcp_url, grantId: "" };
+            const listed = await send(app, conn, "tools/list", {});
+            expect(listed.status === 200, `the paired grant answers tools/list with HTTP ${listed.status}`);
+        }),
+    ];
+}
 /** The mobile rule (APC 0.6): on a phone the agents are in the page, never collapsed, and a finger can pin and unpin. */
 function mobileChecks(app, mobile) {
     const [first, second] = app.targets;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tineira/apc-conformance",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Agent Pointed Context (APC) conformance: checks an app against the standard, in process with an adapter, or live over HTTP with the apc-conformance command.",
   "keywords": [
     "apc",
@@ -45,7 +45,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@tineira/apc-protocol": "^0.8.0"
+    "@tineira/apc-protocol": "^0.9.0"
   },
   "scripts": {},
   "types": "./dist/index.d.ts",