@zackbart/connecta 0.28.1 → 0.30.0

package/dist/connectors/resource-uri.js

@@ -0,0 +1,335 @@
+// Deterministic inverse RFC 6570 expansion for advertised resource templates.
+// Each expression consumes up to the leftmost following literal. Ambiguous
+// boundaries are refused rather than searched again with another capture.
+const MAX_URI_LENGTH = 8192;
+const MAX_MATCH_WORK = 262_144;
+/** Bound parsing plus templates × URI length for the whole resource read. */
+export function resourceUriMatchesTemplates(uri, templates, note = () => { }) {
+    let work = 0;
+    for (const template of templates) {
+        work += uri.length + template.uriTemplate.length;
+        if (work > MAX_MATCH_WORK) {
+            note("resource_match_budget_exceeded");
+            return { matched: false, refusal: "resource_match_budget_exceeded" };
+        }
+    }
+    let matched = false;
+    let refusal;
+    for (const template of templates) {
+        const parsed = parse(template.uriTemplate);
+        if (parsed === "resource_template_ambiguous") {
+            note(parsed);
+            refusal = parsed;
+        }
+        else if (parsed && matches(uri, parsed))
+            matched = true;
+    }
+    return matched ? { matched } : { matched, ...(refusal ? { refusal } : {}) };
+}
+export function resourceUriMatchesTemplate(uri, template) {
+    const parsed = parse(template);
+    return typeof parsed === "object" && matches(uri, parsed);
+}
+function parse(template) {
+    if (template.length > MAX_URI_LENGTH)
+        return;
+    const scheme = /^[A-Za-z][A-Za-z0-9+.-]*:/.exec(template)?.[0];
+    if (!scheme)
+        return;
+    const authority = literalAuthority(template.slice(scheme.length));
+    if (authority !== undefined && /[{}]/.test(authority))
+        return;
+    const parts = [];
+    let offset = 0;
+    let count = 0;
+    while (offset < template.length) {
+        const start = template.indexOf("{", offset);
+        if (start < 0)
+            break;
+        const literal = template.slice(offset, start);
+        const end = template.indexOf("}", start + 1);
+        if (literal.includes("}") || end < 0 || ++count > 16)
+            return;
+        const body = template.slice(start + 1, end);
+        const operator = /^[+#./;?&]/.test(body) ? body[0] : "";
+        const specs = body.slice(operator.length).split(",");
+        if (specs.length > 16)
+            return;
+        const variables = [];
+        for (const spec of specs) {
+            const value = /^((?:[A-Za-z0-9_]|%[0-9A-Fa-f]{2})+(?:\.(?:[A-Za-z0-9_]|%[0-9A-Fa-f]{2})+)*)(\*|:[1-9][0-9]{0,3})?$/.exec(spec);
+            if (!value)
+                return;
+            variables.push({
+                name: value[1],
+                explode: value[2] === "*",
+                prefix: value[2]?.startsWith(":") ? Number(value[2].slice(1)) : undefined,
+            });
+        }
+        if (new Set(variables.map((value) => value.name)).size !== variables.length ||
+            (variables.length > 1 && variables.some((value) => value.explode)))
+            return;
+        parts.push(literal, { operator, variables });
+        offset = end + 1;
+    }
+    const tail = template.slice(offset);
+    if (/[{}]/.test(tail))
+        return;
+    parts.push(tail);
+    for (let index = 1; index < parts.length; index += 2) {
+        const expression = parts[index];
+        const literal = parts[index + 1];
+        if ((!literal && index + 2 < parts.length) ||
+            (literal && Array.from(literal).every((character) => expressionCharacter(expression, character)))) {
+            return "resource_template_ambiguous";
+        }
+    }
+    return { parts, scheme, authority };
+}
+function literalAuthority(rest) {
+    if (!rest.startsWith("//"))
+        return;
+    const value = rest.slice(2);
+    const end = value.search(/[/?#]|\{[/?#]/);
+    return end < 0 ? value : value.slice(0, end);
+}
+function expressionCharacter({ operator, variables }, character) {
+    const base = operator === "+" || operator === "#"
+        ? "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_.~!$'()*+@-/,%"
+        : operator === "."
+            ? "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_~-%"
+            : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_.~-%";
+    const syntax = operator === ";"
+        ? ";=,"
+        : operator === "?" || operator === "&"
+            ? operator + "&=,"
+            : operator === "/" || operator === "."
+                ? operator + ","
+                : ",";
+    return (base.includes(character) || syntax.includes(character) || variables.some((value) => value.name.includes(character)));
+}
+// KMP gives a single forward scan even when a literal has repeated prefixes.
+function findLiteral(uri, literal, offset) {
+    const failure = Array.from({ length: literal.length }, () => 0);
+    for (let index = 1, prefix = 0; index < literal.length; index++) {
+        while (prefix && literal[index] !== literal[prefix])
+            prefix = failure[prefix - 1];
+        if (literal[index] === literal[prefix])
+            prefix++;
+        failure[index] = prefix;
+    }
+    for (let index = offset, prefix = 0; index < uri.length; index++) {
+        while (prefix && uri[index] !== literal[prefix])
+            prefix = failure[prefix - 1];
+        if (uri[index] === literal[prefix])
+            prefix++;
+        if (prefix === literal.length)
+            return index + 1 - prefix;
+    }
+    return -1;
+}
+function matches(uri, { parts, scheme, authority }) {
+    if (uri.length > MAX_URI_LENGTH ||
+        !uri.startsWith(scheme) ||
+        (authority === undefined && uri.slice(scheme.length).startsWith("//")))
+        return false;
+    const values = new Map();
+    const capture = (variable, raw, path) => {
+        const decoded = raw.map((value) => safeValue(value, variable.prefix, path));
+        if (decoded.some((value) => value === undefined))
+            return false;
+        const prior = values.get(variable.name) ?? [];
+        prior.push({ parts: decoded, prefix: variable.prefix });
+        values.set(variable.name, prior);
+        return true;
+    };
+    let offset = 0;
+    for (let index = 0; index < parts.length; index++) {
+        const part = parts[index];
+        if (typeof part === "string") {
+            if (!uri.startsWith(part, offset))
+                return false;
+            offset += part.length;
+            continue;
+        }
+        const literal = parts[index + 1];
+        const end = literal ? findLiteral(uri, literal, offset) : uri.length;
+        if (end < 0)
+            return false;
+        const raw = uri.slice(offset, end);
+        offset = end;
+        if (!raw)
+            continue;
+        const { operator, variables } = part;
+        const prefix = operator === "+" ? "" : operator;
+        if (!raw.startsWith(prefix))
+            return false;
+        const body = raw.slice(prefix.length);
+        if (operator === "?" || operator === "&" || operator === ";") {
+            const tokens = body.split(operator === ";" ? ";" : "&");
+            let last = -1;
+            for (const token of tokens) {
+                const equal = token.indexOf("=");
+                const name = equal < 0 ? token : token.slice(0, equal);
+                const next = variables.findIndex((value) => value.name === name);
+                if (next <= last || next < 0 || (equal < 0 && operator !== ";"))
+                    return false;
+                last = next;
+                const variable = variables[next];
+                const value = equal < 0 ? "" : token.slice(equal + 1);
+                if (!capture(variable, variable.prefix === undefined ? value.split(",") : [value], false))
+                    return false;
+            }
+        }
+        else {
+            const separator = operator === "/" || operator === "." ? operator : ",";
+            if (operator === "." && body.includes(".."))
+                return false;
+            const tokens = body.split(separator);
+            if (operator === "/" && tokens.length > 1 && tokens.some((value) => !value))
+                return false;
+            if (variables.length === 1) {
+                const variable = variables[0];
+                const list = variable.prefix === undefined && (variable.explode || (operator !== "/" && operator !== "."));
+                if ((!list && tokens.length > 1) ||
+                    !capture(variable, list ? tokens : [body], operator === "+" || operator === "#"))
+                    return false;
+            }
+            else {
+                if (tokens.length > variables.length)
+                    return false;
+                for (const [i, value] of tokens.entries())
+                    if (!capture(variables[i], [value], operator === "+" || operator === "#"))
+                        return false;
+            }
+        }
+    }
+    if (offset !== uri.length)
+        return false;
+    const candidates = new Map();
+    for (const [name, occurrences] of values) {
+        const candidate = occurrences.find((value) => value.prefix === undefined || Array.from(value.parts[0]).length < value.prefix) ??
+            occurrences.reduce((a, b) => (a.parts[0].length >= b.parts[0].length ? a : b));
+        if (!occurrences.every((value) => value.prefix === undefined
+            ? JSON.stringify(value.parts) === JSON.stringify(candidate.parts)
+            : value.parts.length === 1 &&
+                value.parts[0] === Array.from(candidate.parts[0]).slice(0, value.prefix).join("")))
+            return false;
+        candidates.set(name, candidate.parts);
+    }
+    const expanded = parts.map((part) => (typeof part === "string" ? part : expand(part, candidates))).join("");
+    const canonical = (text) => text.replace(/%[0-9a-f]{2}/gi, (value) => value.toUpperCase());
+    // Empty expressions can join literals into an authority the template did
+    // not advertise. Compare the final RFC 3986 authority after re-expansion.
+    const rest = uri.slice(scheme.length);
+    return (canonical(expanded) === canonical(uri) &&
+        literalAuthority(rest) === authority &&
+        sameHost(uri, scheme, authority) &&
+        safePath(authority === undefined ? rest : rest.slice(authority.length + 2)));
+}
+function sameHost(uri, scheme, authority) {
+    // WHATWG special schemes can turn an RFC 3986 path into a host. A literal
+    // authority supplies the expected host, including normal port/IDNA handling;
+    // without one, WHATWG must also find no host. Parser errors stay local.
+    if (authority !== undefined && /[\\\p{Cc}\p{Cf}]/u.test(authority))
+        return false;
+    try {
+        const host = authority === undefined ? "" : new URL(`${scheme}//${authority}/`).host;
+        return new URL(uri).host === host;
+    }
+    catch {
+        return false;
+    }
+}
+function safePath(path) {
+    // Inspect the RFC 3986 path before WHATWG removes dot segments. Empty
+    // captures can combine with literals to make traversal absent from any
+    // individual value. Queries and fragments do not contribute path segments.
+    const end = path.search(/[?#]/);
+    let value = end < 0 ? path : path.slice(0, end);
+    for (let depth = 0; depth < 8; depth++) {
+        if (/[\\\p{Cc}\p{Cf}]/u.test(value) || unsafeUnicode(value) || /(?:^|\/)\.{1,2}(?:\/|$)/.test(value))
+            return false;
+        if (!value.includes("%") || (depth > 0 && !/%[0-9a-f]{2}/i.test(value)))
+            return true;
+        try {
+            value = depth === 0 ? decodeURIComponent(value) : decodeNestedPercentEscapes(value);
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+function expand({ operator, variables }, values) {
+    const named = operator === ";" || operator === "?" || operator === "&";
+    const prefix = operator === "+" ? "" : operator;
+    const separator = operator === "/" || operator === "." || operator === ";" ? operator : named ? "&" : ",";
+    const encode = (value) => operator === "+" || operator === "#"
+        ? value
+            .split(/(%[0-9a-f]{2})/gi)
+            .map((part) => (/^%[0-9a-f]{2}$/i.test(part) ? part : encodeURI(part)))
+            .join("")
+        : encodeURIComponent(value).replace(/[!'()*]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`);
+    const nameValue = (name, value) => named ? name + (value || operator !== ";" ? `=${value}` : "") : value;
+    const expansions = [];
+    for (const variable of variables) {
+        const parts = values.get(variable.name);
+        if (!parts)
+            continue;
+        const encoded = parts.map((value) => encode(variable.prefix === undefined ? value : Array.from(value).slice(0, variable.prefix).join("")));
+        expansions.push(variable.explode && parts.length > 1
+            ? encoded.map((value) => nameValue(variable.name, value)).join(separator)
+            : nameValue(variable.name, encoded.join(",")));
+    }
+    return expansions.length ? prefix + expansions.join(separator) : "";
+}
+function safeValue(raw, prefix, path) {
+    let expanded;
+    try {
+        expanded = decodeURIComponent(raw);
+    }
+    catch {
+        return undefined;
+    }
+    let value = expanded;
+    // Check each decoding layer. Reserved paths may contain slashes, but cannot
+    // introduce URI syntax, a network path, traversal, controls or format marks.
+    for (let depth = 0; depth < 8; depth++) {
+        if (/[\\:?#&;=\p{Cc}\p{Cf}]/u.test(value) ||
+            unsafeUnicode(value) ||
+            (!path && value.includes("/")) ||
+            value.startsWith("/") ||
+            value.split("/").some((segment) => segment === "." || segment === ".."))
+            return undefined;
+        if (!/%[0-9a-f]{2}/i.test(value))
+            return prefix === undefined || Array.from(expanded).length <= prefix ? expanded : undefined;
+        try {
+            value = decodeNestedPercentEscapes(value);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+function decodeNestedPercentEscapes(value) {
+    // The first decode stays strict. Later layers can contain literal percent
+    // signs decoded from %25. Preserve those while decoding every remaining
+    // %HH escape, so literal data cannot hide unsafe escapes elsewhere. Invalid
+    // UTF-8 still throws and the callers keep the same eight-layer bound.
+    return decodeURIComponent(value.replace(/%(?![0-9a-f]{2})/gi, "%25"));
+}
+function unsafeUnicode(value) {
+    // Refuse non-ASCII separators and compatibility lookalikes of URI syntax,
+    // rather than all non-ASCII. Ordinary percent-encoded UTF-8 path segments
+    // and ASCII spaces remain valid. Inspect every decoding layer without
+    // normalizing the value used for expansion.
+    for (const character of value) {
+        if (character <= "\x7f")
+            continue;
+        if (/\p{Z}/u.test(character) || /[\\/:?#&;=.%@]/.test(character.normalize("NFKC")))
+            return true;
+    }
+    return false;
+}

package/dist/credential-contract.d.ts

@@ -27,6 +27,16 @@ export interface CredentialVault {
      * Without both `seal` and `open`, that state is stored as plaintext.
      */
     seal?(connectorId: string, purpose: string, plaintext: string, owner?: string): Promise<string>;
+    /** Sign browser OAuth handoffs with a purpose-specific key; nothing is stored. */
+    signOAuthHandoff?(payload: string): Promise<string>;
+    /** Verify a browser OAuth handoff signature without exposing the key. */
+    verifyOAuthHandoff?(payload: string, signature: string): Promise<boolean>;
+    /**
+     * Host-only key for the MCP request-state codec. Must be a stable,
+     * purpose-specific deployment key of at least 32 bytes. The registry never
+     * exposes the vault or this key through a connector context or guest API.
+     */
+    requestStateKey?(): Promise<Uint8Array>;
     /** Reverse `seal` for the same connector, purpose, and owner; rejects otherwise. */
     open?(connectorId: string, purpose: string, sealed: string, owner?: string): Promise<string>;
 }

package/dist/credential-rules.js

@@ -25,9 +25,7 @@ export const STORED_CREDENTIAL_SHAPE_MISMATCH_ERROR = "Stored credential fields
 export function storedCredentialShape(config, stored) {
     if (!stored)
         return { state: "missing" };
-    const mode = config.fields?.length
-        ? "multiple"
-        : "single";
+    const mode = config.fields?.length ? "multiple" : "single";
     const declared = new Set(mode === "multiple" ? config.fields.map((field) => field.name) : ["value"]);
     const actual = Object.keys(stored);
     const present = new Set(actual);

package/dist/credential-url.js

@@ -0,0 +1,108 @@
+import { ConnectorCallError } from "./errors.js";
+function refused() {
+    throw new ConnectorCallError("connector_call_failed", "OAuth metadata or consent URL cannot be safely checked; refusing authorization.", { retryable: false });
+}
+/** Matching only: never change the endpoint that discovery supplied. */
+export function percentDecoded(value) {
+    for (let pass = 0; pass < 8; pass++) {
+        const next = value.replace(/(?:%[0-9a-f]{2})+/gi, (escaped) => {
+            try {
+                return decodeURIComponent(escaped);
+            }
+            catch {
+                // Replacement decoding preserves valid UTF-8 beside malformed bytes.
+                const bytes = escaped.match(/%[0-9a-f]{2}/gi);
+                return new TextDecoder().decode(Uint8Array.from(bytes, (byte) => parseInt(byte.slice(1), 16)));
+            }
+        });
+        if (next === value)
+            return value;
+        value = next;
+    }
+    // Deeper nesting has no stable matching view within the normalization bound.
+    if (/%[0-9a-f]{2}/i.test(value))
+        refused();
+    return value;
+}
+/** RFC 3492 decoding, using no Node-only URL or punycode implementation. URL
+ * has already validated the ASCII host. Bound arithmetic and Unicode scalars. */
+function unicodeLabel(label) {
+    if (!label.startsWith("xn--"))
+        return label;
+    const input = label.slice(4);
+    const delimiter = input.lastIndexOf("-");
+    const output = delimiter < 0 ? [] : Array.from(input.slice(0, delimiter), (char) => char.charCodeAt(0));
+    let cursor = delimiter < 0 ? 0 : delimiter + 1;
+    let n = 128;
+    let i = 0;
+    let bias = 72;
+    while (cursor < input.length) {
+        const previous = i;
+        let weight = 1;
+        for (let k = 36;; k += 36) {
+            const code = input.charCodeAt(cursor++);
+            const digit = code >= 97 && code <= 122 ? code - 97 : code >= 48 && code <= 57 ? code - 22 : 36;
+            if (digit >= 36)
+                refused();
+            i += digit * weight;
+            if (!Number.isSafeInteger(i))
+                refused();
+            const threshold = k <= bias ? 1 : k >= bias + 26 ? 26 : k - bias;
+            if (digit < threshold)
+                break;
+            weight *= 36 - threshold;
+            if (!Number.isSafeInteger(weight))
+                refused();
+        }
+        const count = output.length + 1;
+        let delta = previous === 0 ? Math.floor((i - previous) / 700) : Math.floor((i - previous) / 2);
+        delta += Math.floor(delta / count);
+        let k = 0;
+        while (delta > 455) {
+            delta = Math.floor(delta / 35);
+            k += 36;
+        }
+        bias = k + Math.floor((36 * delta) / (delta + 38));
+        n += Math.floor(i / count);
+        if (n > 0x10ffff || (n >= 0xd800 && n <= 0xdfff))
+            refused();
+        i %= count;
+        output.splice(i++, 0, n);
+    }
+    return String.fromCodePoint(...output);
+}
+/** Decode each component, and concatenate with and without query names so a
+ * credential split across path/query boundaries still matches. Hosts have
+ * ASCII and Unicode views and match case-insensitively; paths remain exact. */
+export function credentialUrlViews(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        return refused();
+    }
+    const host = url.hostname.toLowerCase();
+    const hosts = [host, host.split(".").map(unicodeLabel).join(".").toLowerCase()];
+    const path = url.pathname.split("/").map(percentDecoded);
+    const query = [...url.searchParams].map(([key, item]) => [percentDecoded(key), percentDecoded(item)]);
+    const prefix = [url.protocol, percentDecoded(url.username), percentDecoded(url.password)];
+    const suffix = [percentDecoded(url.hash.slice(1))];
+    const components = [
+        value,
+        percentDecoded(url.href),
+        ...prefix,
+        ...hosts,
+        url.port,
+        percentDecoded(url.pathname),
+        percentDecoded(url.search),
+        ...path,
+        ...query.flat(),
+        ...suffix,
+    ];
+    const joined = hosts.flatMap((hostname) => [
+        [...prefix, hostname, url.port, ...path, ...query.flat(), ...suffix].join(""),
+        [...prefix, hostname, url.port, ...path, ...query.map((entry) => entry[1]), ...suffix].join(""),
+    ]);
+    return { hosts, components, joined };
+}

package/dist/credentials.d.ts

@@ -2,14 +2,19 @@ import type { CredentialMetadata, CredentialVault as Vault } from "./credential-
 import type { ConnectorCredentialValues, KVStorage } from "./types.js";
 /**
  * Encrypted, connector-scoped credential vault over the deployment's existing
- * KVStorage. Only ciphertext enters KV; the AES-GCM key remains an environment
+ * KVStorage. Only ciphertext enters storage; the AES-GCM key remains an environment
  * secret outside the store. The same key seals downstream OAuth state, which
  * the OAuth provider stores itself.
  */
 export declare class CredentialVault implements Vault {
     private readonly storage;
     private readonly key;
+    private readonly handoffKey;
+    private readonly retryKey;
     constructor(storage: KVStorage, encryptionKey: string);
+    signOAuthHandoff(payload: string): Promise<string>;
+    requestStateKey(): Promise<Uint8Array>;
+    verifyOAuthHandoff(payload: string, signature: string): Promise<boolean>;
     private additionalData;
     private read;
     get(connectorId: string, field?: string, owner?: string): Promise<string | null>;

package/dist/credentials.js

@@ -1,3 +1,5 @@
+import { deriveOAuthHandoffKey, deriveRequestStateKey } from "./oauth-sealing.js";
+import { credentialKeys } from "./storage/keys.js";
 const KEY_BYTES = 32;
 const IV_BYTES = 12;
 const MAX_CREDENTIAL_BYTES = 16_384;
@@ -14,9 +16,7 @@ function oauthStateAdditionalData(connectorId, purpose, owner) {
     return encoder.encode(`connecta:oauth-state:v1|${connectorId}|${owner ?? ""}|${purpose}`);
 }
 function storageKey(connectorId, owner) {
-    return owner
-        ? `principal:${owner}:conn:${connectorId}:credential:v1`
-        : `conn:${connectorId}:credential:v1`;
+    return credentialKeys.credential(connectorId, owner);
 }
 function bytesToBase64(bytes) {
     let binary = "";
@@ -52,14 +52,11 @@ function parseEnvelope(raw) {
 function parsePlaintext(raw) {
     try {
         const parsed = JSON.parse(raw);
-        const values = typeof parsed.value === "string"
-            ? { value: parsed.value }
-            : parsed.values;
+        const values = typeof parsed.value === "string" ? { value: parsed.value } : parsed.values;
         if (!values ||
             typeof values !== "object" ||
             Array.isArray(values) ||
-            !Object.entries(values).every(([field, value]) => /^[A-Za-z][A-Za-z0-9_-]*$/.test(field) &&
-                typeof value === "string") ||
+            !Object.entries(values).every(([field, value]) => /^[A-Za-z][A-Za-z0-9_-]*$/.test(field) && typeof value === "string") ||
             typeof parsed.updatedAt !== "string" ||
             typeof parsed.updatedBy !== "string") {
             throw new Error("invalid plaintext");
@@ -88,33 +85,48 @@ function validateValues(values) {
         }
         normalized[field] = value;
     }
-    if (encoder.encode(JSON.stringify(normalized)).byteLength >
-        MAX_CREDENTIAL_BYTES) {
+    if (encoder.encode(JSON.stringify(normalized)).byteLength > MAX_CREDENTIAL_BYTES) {
         throw new Error(`Credential cannot exceed ${MAX_CREDENTIAL_BYTES} bytes`);
     }
     return normalized;
 }
 /**
  * Encrypted, connector-scoped credential vault over the deployment's existing
- * KVStorage. Only ciphertext enters KV; the AES-GCM key remains an environment
+ * KVStorage. Only ciphertext enters storage; the AES-GCM key remains an environment
  * secret outside the store. The same key seals downstream OAuth state, which
  * the OAuth provider stores itself.
  */
 export class CredentialVault {
     storage;
     key;
+    handoffKey;
+    retryKey;
     constructor(storage, encryptionKey) {
         this.storage = storage;
         const raw = base64ToBytes(encryptionKey.trim());
         if (raw.byteLength !== KEY_BYTES) {
             throw new Error("The credential vault encryption key must be a base64-encoded 32-byte key");
         }
+        this.handoffKey = deriveOAuthHandoffKey(raw);
+        this.retryKey = deriveRequestStateKey(raw);
         this.key = crypto.subtle.importKey("raw", raw, { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
     }
+    async signOAuthHandoff(payload) {
+        return bytesToBase64(new Uint8Array(await crypto.subtle.sign("HMAC", await this.handoffKey, encoder.encode(payload))));
+    }
+    async requestStateKey() {
+        return new Uint8Array(await this.retryKey);
+    }
+    async verifyOAuthHandoff(payload, signature) {
+        try {
+            return await crypto.subtle.verify("HMAC", await this.handoffKey, base64ToBytes(signature), encoder.encode(payload));
+        }
+        catch {
+            return false;
+        }
+    }
     additionalData(connectorId, owner) {
-        return encoder.encode(owner
-            ? `connecta:credential:principal:${owner}:${connectorId}:v1`
-            : `connecta:credential:${connectorId}:v1`);
+        return encoder.encode(owner ? `connecta:credential:principal:${owner}:${connectorId}:v1` : `connecta:credential:${connectorId}:v1`);
     }
     async read(connectorId, owner) {
         const raw = await this.storage.get(storageKey(connectorId, owner));
@@ -207,10 +219,7 @@ export class CredentialVault {
     /** Decrypt what `seal` produced for this connector, purpose, and owner. */
     async open(connectorId, purpose, sealed, owner) {
         const [version, iv, ciphertext, ...rest] = sealed.split(".");
-        if (version !== SEALED_VERSION ||
-            iv === undefined ||
-            ciphertext === undefined ||
-            rest.length > 0) {
+        if (version !== SEALED_VERSION || iv === undefined || ciphertext === undefined || rest.length > 0) {
             throw new Error("Sealed OAuth state is invalid or corrupted");
         }
         try {