@idpartners/client-attestation-sdk 0.2.0 → 1.0.0

package/README.md

@@ -17,10 +17,32 @@ ports and is judged by a shared Java verifier. Built on [panva `jose`](https://g
 
 ## Install / build
 
-Requires **Node 20+**. The package uses Node built-ins (`node:crypto`, `node:fs`, and
-`node:child_process` for the SPIRE evidence source), so it does not run on edge or browser runtimes.
+Requires **Node 20+**, or an edge runtime with WebCrypto and `fetch` (Cloudflare Workers, Vercel Edge,
+Deno Deploy) with no Node compatibility layer needed. Crypto, encoding and HTTP use web-standard APIs, and
+nothing imports a Node built-in at load time, so the builders, the one-call `ClientAttestation` flow, the
+issuance client and the token validator all work on the edge.
+
+CI tests this in a real Workers runtime: `npm run test:edge` bundles the package as an edge bundler would
+and runs it in [`workerd`](https://github.com/cloudflare/workerd), Cloudflare's open-source Workers runtime
+(1.20261007.1, compatibility date 2026-10-01, Node compatibility switched off). It generates keys, builds an
+attestation, a PoP and a DPoP proof, and runs the token validator against the shared validation vectors.
+Vercel Edge and Deno Deploy are not tested directly.
+
+Evidence gathering is the part that needs Node. Each of these loads the built-in it needs on first use; the
+two sources throw a `ClientAttestationError` naming themselves from `fetch` on a runtime without it:
+
+- `SpireWorkloadApiSvidSource` runs the `spire-agent` CLI (`node:child_process`);
+- `FileTokenSvidSource` reads a projected token file (`node:fs`);
+- `autoDetectEvidence` reads environment variables and probes for token files and the SPIRE socket. On
+  the edge those all read as absent, so it falls through to the GCP metadata server and then throws
+  `EvidenceNotFound`. Pass an explicit `SvidSource` to `ClientAttestation` there: `StaticSvidSource`,
+  your own, or `HttpSvidSource` in development.
 
-Not on npm yet (it will publish as `@idpartners/client-attestation-sdk`). Build from a clone:
+```bash
+npm install @idpartners/client-attestation-sdk
+```
+
+To build from a clone:
 
 ```bash
 npm install
@@ -97,9 +119,17 @@ and the challenge response is returned instead. The token request itself retries
 - `challengeAtToken: false` keeps the attester challenge in the mint's instance proof but leaves it out
   of the token-endpoint PoP `challenge` claim / DPoP `nonce` - for attesters that consume a challenge at
   mint and reject it when the token request presents it again.
-- The PingFederate host and every endpoint the attester advertises must be `https`, except loopback
+- The attester URL and every endpoint the attester advertises must be `https`, except loopback
   (`localhost`, `127.0.0.1`, `::1`). Pass `allowInsecure: true` for, say, an in-cluster plain-http PF.
 
+### Other attesters
+
+`ClientAttestation` speaks PingFederate's discovery and mint protocol by default. For another attester,
+pass the `profile` option (your own `AttesterProfile`), or the `metadata` option to give its endpoints
+directly and skip discovery: `new ClientAttestation({ metadata: { evidenceAudience, attestationEndpoint,
+tokenEndpoint } })`. `AttestationIssuanceClient.create` takes `{ profile }` too. See
+[`docs/attester-profiles.md`](../docs/attester-profiles.md).
+
 The validator's `ProtectedResource` strips control characters from every quoted `WWW-Authenticate` value,
 and validation failures never echo the token's own `alg`, `kid`, `iss` or `aud` back in
 `error_description`.
@@ -108,5 +138,6 @@ and validation failures never echo the token's own `alg`, `kid`, `iss` or `aud`
 
 ```bash
 npm test        # vitest — self-verifies each artifact with jose
+npm run test:edge   # the same SDK in workerd, Cloudflare's Workers runtime, with no Node compatibility
 npm run emit    # writes ../vectors/out/typescript.json for the cross-language Java verifier
 ```

package/dist/attester.d.ts

@@ -0,0 +1,93 @@
+import { type SigningKeyPair } from "./signing-key-pair.js";
+/** Where the attester lives and what it expects. */
+export interface AttesterMetadata {
+    /** The audience the workload's platform identity is requested for, and the instance proof's `aud`. */
+    evidenceAudience?: string;
+    /** Where the mint request goes. */
+    attestationEndpoint?: string;
+    /** The authorization server's token endpoint. A profile fills in its own fallback. */
+    tokenEndpoint?: string;
+    /** The draft's challenge endpoint, if the attester issues challenges. */
+    challengeEndpoint?: string;
+    /** The Client Attestation PoP `aud` (the AS issuer); falls back to the token endpoint URL. */
+    popAudience?: string;
+    /** The raw discovery document, when there was one; returned by `ClientAttestation.discovery()`. */
+    document?: Record<string, unknown>;
+}
+/** What the attester returned: the attestation, and its lifetime in seconds if it said. */
+export interface MintResult {
+    attestation: string;
+    expiresIn?: number;
+}
+/**
+ * How a profile talks to the attester. The client supplies it, so every call shares the client's timeout,
+ * redirect and size limits, https rule and logging (`http.failed`).
+ */
+export interface AttesterTransport {
+    /**
+     * Send `body` (as JSON, if given) and resolve to the JSON object response. `step` names the call in
+     * logs (`discover`, `mint`). Rejects on a non-2xx status or a body that is not a JSON object.
+     */
+    requestJson(step: string, method: string, url: string, body?: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+/**
+ * The attester-specific part of the flow. Implement it and pass it as the `profile` option.
+ *
+ * @experimental See docs/api.md: new in 0.4.0 and fitted to one real attester so far; a method added to it would break custom profiles.
+ */
+export interface AttesterProfile {
+    /**
+     * Find the attester's endpoints. Called once per client and cached; not called when the caller passes
+     * static `metadata`.
+     */
+    discover(transport: AttesterTransport, attesterUrl: string | undefined): Promise<AttesterMetadata>;
+    /** Exchange the evidence and a proof of the instance key for an attestation. */
+    mint(transport: AttesterTransport, metadata: AttesterMetadata, request: MintRequest): Promise<MintResult>;
+}
+/** Everything a profile needs to mint one attestation. */
+export declare class MintRequest {
+    /** The fresh key the attestation will be bound to (its `cnf`). */
+    readonly instanceKey: SigningKeyPair;
+    /** The workload's platform identity token (a JWT-SVID or equivalent). */
+    readonly evidence: string;
+    /** The attester-issued challenge, if any. */
+    readonly challenge?: string;
+    /** Set by {@link AttestationIssuanceClient}; unset in the evidence-first one-call flow. */
+    readonly clientId?: string;
+    /** Optional RFC 9396 access request. */
+    readonly authorizationDetails?: Array<Record<string, unknown>>;
+    /** Optional operator object (who answers for this workload). */
+    readonly operator?: Record<string, unknown>;
+    constructor(init: {
+        instanceKey: SigningKeyPair;
+        evidence: string;
+        challenge?: string;
+        clientId?: string;
+        authorizationDetails?: Array<Record<string, unknown>>;
+        operator?: Record<string, unknown>;
+    });
+    /** Sign `claims` as a compact JWS with the instance key, under header `typ` (no `jwk`). */
+    sign(claims: Record<string, unknown>, typ: string): Promise<string>;
+    /** A proof of possession of the instance key: `{aud, jti, iat[, challenge]}` signed with it. */
+    instanceProof(typ: string, audience: string | undefined): Promise<string>;
+}
+/** The instance-key proof typ of the PingFederate profile (server InstanceKeyProofValidator.TYP). */
+export declare const INSTANCE_PROOF_TYP = "oauth-attestation-instance-proof+jwt";
+/**
+ * The attester this SDK was built against (PingFederate), and the default.
+ *
+ * - Discovery: `GET {attesterUrl}/.well-known/client-attester`, a JSON object with `evidence_audience`,
+ *   `attestation_endpoint`, `challenge_endpoint`, `token_endpoint` and `pop_audience`. With no
+ *   `token_endpoint`, `{attesterUrl}/as/token.oauth2`.
+ * - Mint: `POST attestation_endpoint` with JSON `{[client_id,] instance_key, svid, proof
+ *   [, authorization_details][, operator]}`, where `proof` is `{aud: evidence_audience, jti, iat
+ *   [, challenge]}` signed by the instance key with `typ` `oauth-attestation-instance-proof+jwt`. The
+ *   response is `{"attestation": ..., "expires_in": ...}`.
+ */
+export declare class PingFederateProfile implements AttesterProfile {
+    static readonly WELL_KNOWN_PATH = "/.well-known/client-attester";
+    static readonly INSTANCE_PROOF_TYP = "oauth-attestation-instance-proof+jwt";
+    static readonly DEFAULT_TOKEN_PATH = "/as/token.oauth2";
+    discover(transport: AttesterTransport, attesterUrl: string | undefined): Promise<AttesterMetadata>;
+    mint(transport: AttesterTransport, metadata: AttesterMetadata, request: MintRequest): Promise<MintResult>;
+}

package/dist/attester.js

@@ -0,0 +1,139 @@
+/**
+ * Attester profiles: the part of the flow that differs from one attester to the next.
+ *
+ * The draft says what a Client Attestation, its PoP and the challenge endpoint look like, and how they
+ * are presented at the token endpoint. It does not say how a workload gets an attestation from its
+ * attester. That part - where the attester's endpoints are listed, what the mint request looks like, how
+ * the instance key is proven, and what comes back - is an {@link AttesterProfile}.
+ *
+ * {@link ClientAttestation} and {@link AttestationIssuanceClient} use {@link PingFederateProfile} unless
+ * told otherwise, which is exactly the behaviour of earlier releases. See docs/attester-profiles.md.
+ */
+import { ClientAttestationError } from "./errors.js";
+import { signCompact } from "./signing-key-pair.js";
+/** Everything a profile needs to mint one attestation. */
+export class MintRequest {
+    /** The fresh key the attestation will be bound to (its `cnf`). */
+    instanceKey;
+    /** The workload's platform identity token (a JWT-SVID or equivalent). */
+    evidence;
+    /** The attester-issued challenge, if any. */
+    challenge;
+    /** Set by {@link AttestationIssuanceClient}; unset in the evidence-first one-call flow. */
+    clientId;
+    /** Optional RFC 9396 access request. */
+    authorizationDetails;
+    /** Optional operator object (who answers for this workload). */
+    operator;
+    constructor(init) {
+        this.instanceKey = init.instanceKey;
+        this.evidence = init.evidence;
+        this.challenge = init.challenge;
+        this.clientId = init.clientId;
+        this.authorizationDetails = init.authorizationDetails;
+        this.operator = init.operator;
+    }
+    /** Sign `claims` as a compact JWS with the instance key, under header `typ` (no `jwk`). */
+    sign(claims, typ) {
+        return signCompact(claims, this.instanceKey, typ, false);
+    }
+    /** A proof of possession of the instance key: `{aud, jti, iat[, challenge]}` signed with it. */
+    instanceProof(typ, audience) {
+        const claims = {
+            aud: audience,
+            jti: crypto.randomUUID(),
+            iat: Math.floor(Date.now() / 1000),
+        };
+        if (this.challenge)
+            claims.challenge = this.challenge;
+        return this.sign(claims, typ);
+    }
+}
+/**
+ * The PingFederate profile's discovery document path.
+ *
+ * @internal
+ */
+export const WELL_KNOWN_PATH = "/.well-known/client-attester";
+/** The instance-key proof typ of the PingFederate profile (server InstanceKeyProofValidator.TYP). */
+export const INSTANCE_PROOF_TYP = "oauth-attestation-instance-proof+jwt";
+/**
+ * The attester this SDK was built against (PingFederate), and the default.
+ *
+ * - Discovery: `GET {attesterUrl}/.well-known/client-attester`, a JSON object with `evidence_audience`,
+ *   `attestation_endpoint`, `challenge_endpoint`, `token_endpoint` and `pop_audience`. With no
+ *   `token_endpoint`, `{attesterUrl}/as/token.oauth2`.
+ * - Mint: `POST attestation_endpoint` with JSON `{[client_id,] instance_key, svid, proof
+ *   [, authorization_details][, operator]}`, where `proof` is `{aud: evidence_audience, jti, iat
+ *   [, challenge]}` signed by the instance key with `typ` `oauth-attestation-instance-proof+jwt`. The
+ *   response is `{"attestation": ..., "expires_in": ...}`.
+ */
+export class PingFederateProfile {
+    static WELL_KNOWN_PATH = WELL_KNOWN_PATH;
+    static INSTANCE_PROOF_TYP = INSTANCE_PROOF_TYP;
+    static DEFAULT_TOKEN_PATH = "/as/token.oauth2";
+    async discover(transport, attesterUrl) {
+        if (!attesterUrl)
+            throw new Error("attesterUrl is required for discovery");
+        const doc = await transport.requestJson("discover", "GET", attesterUrl + WELL_KNOWN_PATH);
+        const str = (key) => (typeof doc[key] === "string" && doc[key] ? doc[key] : undefined);
+        return {
+            evidenceAudience: str("evidence_audience"),
+            attestationEndpoint: str("attestation_endpoint"),
+            // token_endpoint is advertised by current attesters; fall back to the standard PF path so an older
+            // discovery document still works from the host alone.
+            tokenEndpoint: str("token_endpoint") ?? attesterUrl + PingFederateProfile.DEFAULT_TOKEN_PATH,
+            challengeEndpoint: str("challenge_endpoint"),
+            popAudience: str("pop_audience"),
+            document: doc,
+        };
+    }
+    async mint(transport, metadata, request) {
+        if (!metadata.attestationEndpoint) {
+            throw new ClientAttestationError("attester discovery document has no attestation_endpoint");
+        }
+        const proof = await request.instanceProof(INSTANCE_PROOF_TYP, metadata.evidenceAudience);
+        const body = {};
+        if (request.clientId)
+            body.client_id = request.clientId;
+        body.instance_key = request.instanceKey.publicJwk();
+        body.svid = request.evidence;
+        body.proof = proof;
+        if (request.authorizationDetails)
+            body.authorization_details = request.authorizationDetails;
+        // Asked for at mint time so the ATTESTER is what states the operator, rather than the client
+        // asserting it about itself at the token endpoint. An attester that does not know it ignores it.
+        if (request.operator)
+            body.operator = request.operator;
+        const response = await transport.requestJson("mint", "POST", metadata.attestationEndpoint, body);
+        const attestation = response.attestation;
+        if (typeof attestation !== "string" || !attestation) {
+            throw new ClientAttestationError("attester response contained no attestation", {
+                body: JSON.stringify(response),
+            });
+        }
+        const expiresIn = response.expires_in;
+        return { attestation, expiresIn: typeof expiresIn === "number" ? expiresIn : undefined };
+    }
+}
+/**
+ * The discovery-document view of metadata: the raw document, or the snake_case fields that are set.
+ *
+ * @internal
+ */
+export function metadataDocument(metadata) {
+    if (metadata.document)
+        return metadata.document;
+    const doc = {};
+    const fields = [
+        ["evidence_audience", metadata.evidenceAudience],
+        ["attestation_endpoint", metadata.attestationEndpoint],
+        ["challenge_endpoint", metadata.challengeEndpoint],
+        ["token_endpoint", metadata.tokenEndpoint],
+        ["pop_audience", metadata.popAudience],
+    ];
+    for (const [key, value] of fields)
+        if (value)
+            doc[key] = value;
+    return doc;
+}

package/dist/builders.d.ts

@@ -1,4 +1,7 @@
-import type { JWK } from "jose";
+/**
+ * Builders for the attestation, PoP and DPoP JWTs (draft-ietf-oauth-attestation-based-client-auth).
+ */
+import { type JWK } from "jose";
 import { SigningKeyPair } from "./signing-key-pair.js";
 import { type JwsSigner } from "./signer.js";
 export declare const ATTESTATION_TYP = "oauth-client-attestation+jwt";
@@ -87,10 +90,3 @@ export declare class DpopProofBuilder {
     issuedAt(epochSeconds: number): this;
     build(): Promise<string>;
 }
-/** RFC 9449 `ath`: base64url(SHA-256(ASCII access token)). */
-export declare function accessTokenHash(accessToken: string): string;
-/**
- * The DPoP `htu` for a URL: scheme, host, port and path, with no query and no fragment. Scheme and host
- * are lower-cased and a default port dropped; a URL with no path keeps none (no slash is invented).
- */
-export declare function normalizeHtu(url: string): string;

package/dist/builders.js

@@ -1,8 +1,9 @@
 /**
  * Builders for the attestation, PoP and DPoP JWTs (draft-ietf-oauth-attestation-based-client-auth).
  */
-import { createHash, randomUUID } from "node:crypto";
+import { base64url } from "jose";
 import { SigningKeyPair, requireText, signCompact } from "./signing-key-pair.js";
+import { utf8Encode } from "./runtime.js";
 import { signExternal } from "./signer.js";
 export const ATTESTATION_TYP = "oauth-client-attestation+jwt";
 export const POP_TYP = "oauth-client-attestation-pop+jwt";
@@ -172,7 +173,7 @@ export class PopBuilder {
         }
         const claims = {
             aud: this.#audience,
-            jti: this.#jwtId ?? randomUUID(),
+            jti: this.#jwtId ?? crypto.randomUUID(),
             iat: this.#issuedAt !== null ? this.#issuedAt : nowSeconds(),
         };
         if (this.#clientId) {
@@ -193,7 +194,7 @@ export class DpopProofBuilder {
     #htm = "POST";
     #htu = null;
     #nonce = null;
-    #ath = null;
+    #accessToken = null;
     #jwtId = null;
     #issuedAt = null;
     constructor(instanceKey) {
@@ -224,7 +225,7 @@ export class DpopProofBuilder {
      * Leave unset for a proof sent to the token endpoint.
      */
     accessToken(accessToken) {
-        this.#ath = accessToken ? accessTokenHash(accessToken) : null;
+        this.#accessToken = accessToken || null;
         return this;
     }
     jwtId(jwtId) {
@@ -242,25 +243,32 @@ export class DpopProofBuilder {
         const claims = {
             htm: this.#htm.toUpperCase(),
             htu: normalizeHtu(this.#htu),
-            jti: this.#jwtId ?? randomUUID(),
+            jti: this.#jwtId ?? crypto.randomUUID(),
             iat: this.#issuedAt !== null ? this.#issuedAt : nowSeconds(),
         };
         if (this.#nonce) {
             claims.nonce = this.#nonce;
         }
-        if (this.#ath) {
-            claims.ath = this.#ath;
+        if (this.#accessToken) {
+            claims.ath = await accessTokenHash(this.#accessToken);
         }
         return signCompact(claims, this.#instanceKey, DPOP_TYP, true);
     }
 }
-/** RFC 9449 `ath`: base64url(SHA-256(ASCII access token)). */
-export function accessTokenHash(accessToken) {
-    return createHash("sha256").update(accessToken, "ascii").digest("base64url");
+/**
+ * RFC 9449 `ath`: base64url(SHA-256(ASCII access token)).
+ *
+ * @internal
+ */
+export async function accessTokenHash(accessToken) {
+    const digest = await crypto.subtle.digest("SHA-256", utf8Encode(accessToken));
+    return base64url.encode(new Uint8Array(digest));
 }
 /**
  * The DPoP `htu` for a URL: scheme, host, port and path, with no query and no fragment. Scheme and host
  * are lower-cased and a default port dropped; a URL with no path keeps none (no slash is invented).
+ *
+ * @internal
  */
 export function normalizeHtu(url) {
     const bare = url.split(/[?#]/, 1)[0];

package/dist/evidence.d.ts

@@ -9,10 +9,6 @@ export declare const ENV_SPIFFE_SOCKET = "SPIFFE_ENDPOINT_SOCKET";
 export declare const DEFAULT_TOKEN_FILE = "/var/run/secrets/tokens/attester-token";
 /** Default SPIRE agent socket path. */
 export declare const DEFAULT_SPIFFE_SOCKET = "/tmp/spire-agent/public/api.sock";
-/** GCP metadata server origin. */
-export declare const GCP_METADATA_BASE = "http://metadata.google.internal";
-/** GCP metadata server identity endpoint (returns a Google-signed ID token for the runtime SA). */
-export declare const GCP_METADATA_IDENTITY: string;
 /** No platform identity could be detected and none was supplied. */
 export declare class EvidenceNotFound extends Error {
     constructor(message: string);
@@ -23,6 +19,9 @@ export declare class EvidenceNotFound extends Error {
  * Kubernetes and GKE mount a short-lived, auto-rotated service-account token into the pod as a file
  * (a projected `serviceAccountToken` volume). Reading it fresh each time picks up the rotation. The
  * file's audience must already be the attester's evidence audience — set it when you declare the volume.
+ *
+ * Needs a filesystem: `node:fs/promises` is loaded on the first `fetch`, which throws a
+ * `ClientAttestationError` on a runtime without it.
  */
 export declare class FileTokenSvidSource implements SvidSource {
     private readonly path;
@@ -46,20 +45,6 @@ export declare class GoogleMetadataSvidSource implements SvidSource {
     constructor(timeoutMs?: number, identityUrl?: string);
     fetch(audience: string): Promise<string>;
 }
-/**
- * Internal overrides for {@link autoDetectEvidence}, so tests can point detection at fixtures instead
- * of the host's real paths and the real GCP metadata server. Not part of the supported API.
- *
- * @internal
- */
-export interface AutoDetectOptions {
-    /** Path probed in place of {@link DEFAULT_TOKEN_FILE}. */
-    defaultTokenFile?: string;
-    /** Path probed in place of {@link DEFAULT_SPIFFE_SOCKET}. */
-    defaultSpiffeSocket?: string;
-    /** Origin used in place of {@link GCP_METADATA_BASE} for the probe and the identity call. */
-    gcpMetadataBase?: string;
-}
 /**
  * Return the first evidence source that applies to this runtime, or throw with guidance.
  *
@@ -67,4 +52,4 @@ export interface AutoDetectOptions {
  * by an environment variable ({@link ENV_TOKEN_FILE}, {@link ENV_SPIFFE_SOCKET}) whose path does not
  * exist throws {@link EvidenceNotFound} naming the variable; it never falls through to the next source.
  */
-export declare function autoDetectEvidence(opts?: AutoDetectOptions): Promise<SvidSource>;
+export declare function autoDetectEvidence(): Promise<SvidSource>;

package/dist/evidence.js

@@ -10,13 +10,12 @@
  * - the GCP metadata server (GCE, GKE, Cloud Run, Vertex AI Agent Engine).
  *
  * {@link autoDetectEvidence} tries these in order and returns the first that applies, so a developer
- * can write `new ClientAttestation(pfHost)` and have it work without naming the source. Override by
+ * can write `new ClientAttestation(attesterUrl)` and have it work without naming the source. Override by
  * passing an explicit {@link SvidSource} to {@link ClientAttestation}.
  */
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
 import { TransportError } from "./errors.js";
 import { request, snippet } from "./http.js";
+import { envVar, importNodeBuiltin } from "./runtime.js";
 import { SpireWorkloadApiSvidSource, StaticSvidSource } from "./svid-source.js";
 /** Environment variable holding the evidence token itself (static). */
 export const ENV_SVID = "CLIENT_ATTESTATION_SVID";
@@ -28,9 +27,17 @@ export const ENV_SPIFFE_SOCKET = "SPIFFE_ENDPOINT_SOCKET";
 export const DEFAULT_TOKEN_FILE = "/var/run/secrets/tokens/attester-token";
 /** Default SPIRE agent socket path. */
 export const DEFAULT_SPIFFE_SOCKET = "/tmp/spire-agent/public/api.sock";
-/** GCP metadata server origin. */
+/**
+ * GCP metadata server origin.
+ *
+ * @internal
+ */
 export const GCP_METADATA_BASE = "http://metadata.google.internal";
-/** GCP metadata server identity endpoint (returns a Google-signed ID token for the runtime SA). */
+/**
+ * GCP metadata server identity endpoint (returns a Google-signed ID token for the runtime SA).
+ *
+ * @internal
+ */
 export const GCP_METADATA_IDENTITY = GCP_METADATA_BASE + "/computeMetadata/v1/instance/service-accounts/default/identity";
 /** No platform identity could be detected and none was supplied. */
 export class EvidenceNotFound extends Error {
@@ -45,6 +52,9 @@ export class EvidenceNotFound extends Error {
  * Kubernetes and GKE mount a short-lived, auto-rotated service-account token into the pod as a file
  * (a projected `serviceAccountToken` volume). Reading it fresh each time picks up the rotation. The
  * file's audience must already be the attester's evidence audience — set it when you declare the volume.
+ *
+ * Needs a filesystem: `node:fs/promises` is loaded on the first `fetch`, which throws a
+ * `ClientAttestationError` on a runtime without it.
  */
 export class FileTokenSvidSource {
     path;
@@ -52,6 +62,7 @@ export class FileTokenSvidSource {
         this.path = path;
     }
     async fetch(_audience) {
+        const { readFile } = await importNodeBuiltin("fs/promises", "FileTokenSvidSource");
         const contents = await readFile(this.path, "utf8");
         return contents.trim();
     }
@@ -90,6 +101,19 @@ export class GoogleMetadataSvidSource {
         return res.body.trim();
     }
 }
+/**
+ * A path-existence check, or one that always answers `false` on a runtime with no filesystem (an edge
+ * runtime), where the file and socket sources cannot apply.
+ */
+async function pathProbe() {
+    try {
+        const { existsSync } = await importNodeBuiltin("fs", "autoDetectEvidence");
+        return existsSync;
+    }
+    catch {
+        return () => false;
+    }
+}
 async function gcpMetadataAvailable(base, timeoutMs = 300) {
     try {
         const res = await request(base + "/computeMetadata/v1/", {
@@ -103,45 +127,39 @@ async function gcpMetadataAvailable(base, timeoutMs = 300) {
         return false;
     }
 }
-/**
- * Return the first evidence source that applies to this runtime, or throw with guidance.
- *
- * Order: explicit env token, projected token file, SPIRE socket, GCP metadata server. A source named
- * by an environment variable ({@link ENV_TOKEN_FILE}, {@link ENV_SPIFFE_SOCKET}) whose path does not
- * exist throws {@link EvidenceNotFound} naming the variable; it never falls through to the next source.
- */
 export async function autoDetectEvidence(opts = {}) {
+    const exists = await pathProbe();
     const defaultTokenFile = opts.defaultTokenFile ?? DEFAULT_TOKEN_FILE;
     const defaultSocket = opts.defaultSpiffeSocket ?? DEFAULT_SPIFFE_SOCKET;
     const metadataBase = (opts.gcpMetadataBase ?? GCP_METADATA_BASE).replace(/\/+$/, "");
-    const staticToken = process.env[ENV_SVID];
+    const staticToken = envVar(ENV_SVID);
     if (staticToken) {
         return new StaticSvidSource(staticToken.trim());
     }
     // An explicitly configured source that is missing is a misconfiguration: fail closed rather than
     // fall through to a different identity the operator did not choose.
-    const tokenFile = process.env[ENV_TOKEN_FILE];
+    const tokenFile = envVar(ENV_TOKEN_FILE);
     if (tokenFile) {
-        if (!existsSync(tokenFile)) {
+        if (!exists(tokenFile)) {
             throw new EvidenceNotFound(`${ENV_TOKEN_FILE} is set to ${tokenFile}, but no such file exists`);
         }
         return new FileTokenSvidSource(tokenFile);
     }
-    if (existsSync(defaultTokenFile)) {
+    if (exists(defaultTokenFile)) {
         return new FileTokenSvidSource(defaultTokenFile);
     }
-    const socket = process.env[ENV_SPIFFE_SOCKET];
+    const socket = envVar(ENV_SPIFFE_SOCKET);
     if (socket) {
         const socketPath = socket.replace(/^unix:\/\//, "");
-        if (!existsSync(socketPath)) {
+        if (!exists(socketPath)) {
             throw new EvidenceNotFound(`${ENV_SPIFFE_SOCKET} is set to ${socket}, but no such socket exists`);
         }
         return new SpireWorkloadApiSvidSource(socketPath);
     }
-    if (existsSync(defaultSocket)) {
+    if (exists(defaultSocket)) {
         return new SpireWorkloadApiSvidSource(defaultSocket);
     }
-    if (await gcpMetadataAvailable(metadataBase)) {
+    if (await gcpMetadataAvailable(metadataBase, opts.gcpProbeTimeoutMs)) {
         return new GoogleMetadataSvidSource(5000, metadataBase + "/computeMetadata/v1/instance/service-accounts/default/identity");
     }
     throw new EvidenceNotFound("Could not auto-detect the workload's platform identity. Set one of " +

package/dist/http.d.ts

@@ -1,41 +1 @@
-export declare const DEFAULT_MAX_BYTES: number;
-export declare const DEFAULT_TIMEOUT_MS = 20000;
-/** At most this many characters of a response body are carried in an error. */
-export declare const ERROR_BODY_CHARS = 512;
-export interface HttpRequestOptions {
-    method?: string;
-    headers?: Record<string, string>;
-    body?: string;
-    /** Whole-call timeout in milliseconds (connect, headers and body). Defaults to 20 s. */
-    timeoutMs?: number;
-    /** Largest response body accepted, in bytes. Defaults to 1 MiB. */
-    maxBytes?: number;
-}
-export interface HttpResponse {
-    method: string;
-    url: string;
-    status: number;
-    ok: boolean;
-    headers: Headers;
-    body: string;
-}
-/** The first {@link ERROR_BODY_CHARS} characters of a body, for an error message. */
-export declare function snippet(body: string): string;
-/**
- * Make one HTTP request. Resolves with the status, headers and body text for any non-3xx response
- * (non-2xx included); rejects with a {@link TransportError} for a network failure, timeout, redirect or
- * oversized body.
- */
-export declare function request(url: string, opts?: HttpRequestOptions): Promise<HttpResponse>;
-/**
- * Parse `res.body` as a JSON object. Throws a {@link TransportError} for a non-2xx status (carrying the
- * status and at most 512 characters of the body) and for a body that is not a JSON object. An empty body
- * reads as `{}` when `allowEmpty` is set.
- */
-export declare function jsonOk<T = Record<string, unknown>>(res: HttpResponse, opts?: {
-    allowEmpty?: boolean;
-}): T;
-/** Parse `res.body` as a JSON object regardless of status; a {@link TransportError} if it is not one. */
-export declare function parseJsonObject<T = Record<string, unknown>>(res: HttpResponse, opts?: {
-    allowEmpty?: boolean;
-}): T;
+export {};