feat(portal-bff): signed-assertion strategy + /.well-known/jwks.json

Second half of the DownstreamApiClient + OBO chantier per ADR-0014.
Ships the signed-assertion strategy (non-Entra downstreams) and the
JWKS publishing endpoint as testable primitives. The framework
around them (DownstreamApiClientFactory, cockatiel, audience
pre-check, error translation) still waits for the first concrete
integration per the ADR's "until then" clause.

What lands

- assertJwksConfig (config/check-jwks-config.ts):
  - Reads the PEM private key once at boot, refuses missing /
    unreadable / weak material (RSA < 2048, Ed25519, unknown key
    type). Derives the JOSE algorithm (RS256 / ES256 / ES384) from
    the key shape so neither the strategy nor the JWKS controller
    has to re-decide on the hot path.
  - Validates BFF_JWKS_KID against [A-Za-z0-9_-]{4,128} so the
    value lives unescaped in JWT headers + JWKS payloads.
  - Wired in main.ts alongside the other assertX() validators.

- BffSigningKey (downstream/bff-signing-key.ts):
  - Singleton holding { config: JwksConfig, publicJwk: JWK }.
    publicJwk is derived from the private key via `jose.exportJWK`
    on a public KeyObject — no private material leaks through.
  - DI token BFF_SIGNING_KEY wires both consumers (strategy +
    controller) to the same source of truth.

- SignedAssertionStrategy (downstream/strategies/signed-assertion.strategy.ts):
  - Wraps `jose.SignJWT` with the ADR-0014 claim shape: iss,
    sub, aud, audience (workforce|customer), claims (curated
    subset), trace_id, iat, exp.
  - 60 s TTL hard-coded — the ADR mandates it; cache disabled
    because the savings on a 60 s JWT would be marginal and a
    cache would let replayed assertions linger past their TTL.
  - kid header matches the JWKS so a downstream picks the right
    key during rotation.
  - Supports RS256 / ES256 / ES384 transparently — picks the alg
    the validator derived at boot.

- JwksController (downstream/jwks.controller.ts):
  - GET /.well-known/jwks.json returns { keys: [<single jwk>] }.
  - main.ts excludes /.well-known/* from the global /api prefix so
    the route lands at the bare root per RFC 8615.
  - No auth gate (the JWKS is the verification anchor — gating it
    would defeat the purpose). Read-only, so the CSRF middleware's
    GET-exempt path already handles it.

Configuration

- Generate a key:
    mkdir -p apps/portal-bff/.secrets && \
    openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:3072 \
      -out apps/portal-bff/.secrets/jwks.pem
- BFF_JWKS_PRIVATE_KEY_PATH (path to the PEM)
- BFF_JWKS_KID (URL-safe id, 4..128 chars)
- Both mandatory at boot.
- `apps/portal-bff/.secrets/` is matched by the repo's existing
  *.pem / *.key gitignore patterns.

Deps

- jose@^6 added as a direct dep (was transitive). Pinned at the
  workspace root since the BFF is the only consumer today and the
  package isn't part of the Angular bundle graph.
- jest.config.cts: jose ships ESM-only, so its node_modules path
  is removed from transformIgnorePatterns. The pattern walks
  pnpm's deep `.pnpm/` layout — anything under /node_modules/ that
  also contains `jose` somewhere in the path gets transformed.

Tests: +24 specs (env validators 11, signing key 4, strategy 6,
controller 3).

Out of scope (deferred per ADR-0014 "until then"):
- DownstreamApiClientFactory + per-service typed config.
- cockatiel resilience composition.
- Audience pre-check at the call site.
- Error translation tables.
- OTel custom spans `downstream.<service>.<verb>.<path>`.
- The framework wiring that calls SignedAssertionStrategy.sign()
  + attaches the `X-User-Assertion` + ServiceCredential auth
  header to outbound HTTP requests.
- Key rotation (the JWKS lists one key for now; rotation chantier
  adds a second entry + a window-based eviction policy).

These land alongside the first concrete integration so the
framework shape is validated against a real consumer.

apps/portal-bff/src/downstream/bff-signing-key.spec.ts

@@ -0,0 +1,60 @@
+import { createPrivateKey, generateKeyPairSync } from 'node:crypto';
+import { buildBffSigningKey } from './bff-signing-key';
+
+function rsaKey() {
+  const { privateKey } = generateKeyPairSync('rsa', { modulusLength: 2048 });
+  return createPrivateKey(privateKey.export({ type: 'pkcs8', format: 'pem' }));
+}
+
+function ecKey(curve: 'prime256v1' | 'secp384r1') {
+  const { privateKey } = generateKeyPairSync('ec', { namedCurve: curve });
+  return createPrivateKey(privateKey.export({ type: 'pkcs8', format: 'pem' }));
+}
+
+describe('buildBffSigningKey', () => {
+  it('produces a public JWK with kid + alg + use=sig from an RSA private key', async () => {
+    const key = await buildBffSigningKey({
+      privateKey: rsaKey(),
+      kid: 'bff-2026-05',
+      alg: 'RS256',
+    });
+    expect(key.publicJwk.kty).toBe('RSA');
+    expect(key.publicJwk.kid).toBe('bff-2026-05');
+    expect(key.publicJwk.alg).toBe('RS256');
+    expect(key.publicJwk.use).toBe('sig');
+    // No private-material leak — the public JWK must not carry `d`, `p`, `q`, `dp`, `dq`, `qi`.
+    expect(key.publicJwk.d).toBeUndefined();
+    expect(key.publicJwk.p).toBeUndefined();
+    expect(key.publicJwk.q).toBeUndefined();
+  });
+
+  it('produces a public JWK with kty=EC + crv=P-256 for an EC P-256 key', async () => {
+    const key = await buildBffSigningKey({
+      privateKey: ecKey('prime256v1'),
+      kid: 'bff-2026-05',
+      alg: 'ES256',
+    });
+    expect(key.publicJwk.kty).toBe('EC');
+    expect(key.publicJwk.crv).toBe('P-256');
+    expect(key.publicJwk.alg).toBe('ES256');
+    expect(key.publicJwk.d).toBeUndefined();
+  });
+
+  it('produces a public JWK with crv=P-384 for an EC P-384 key', async () => {
+    const key = await buildBffSigningKey({
+      privateKey: ecKey('secp384r1'),
+      kid: 'bff-2026-05',
+      alg: 'ES384',
+    });
+    expect(key.publicJwk.crv).toBe('P-384');
+    expect(key.publicJwk.alg).toBe('ES384');
+  });
+
+  it('exposes the full original config on the returned BffSigningKey', async () => {
+    const privateKey = rsaKey();
+    const built = await buildBffSigningKey({ privateKey, kid: 'rotated-kid', alg: 'RS256' });
+    expect(built.config.privateKey).toBe(privateKey);
+    expect(built.config.kid).toBe('rotated-kid');
+    expect(built.config.alg).toBe('RS256');
+  });
+});