diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d2330cb..830127f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -34,18 +34,6 @@ jobs:
       - run: yarn install
       - run: yarn lint:check
 
-  typecheck:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v7
-      - run: corepack enable
-      - uses: actions/setup-node@v6
-        with:
-          node-version-file: .node-version
-          cache: yarn
-      - run: yarn install
-      - run: yarn typecheck
-
   test-matrix:
     runs-on: ubuntu-latest
     strategy:
@@ -81,14 +69,8 @@ jobs:
           cache: yarn
       - run: yarn install
       - run: yarn build
-      - uses: actions/upload-artifact@v7
-        with:
-          name: dist
-          path: dist
-          retention-days: 1
 
   publint:
-    needs: build
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v7
@@ -98,10 +80,5 @@ jobs:
           node-version-file: .node-version
           cache: yarn
       - run: yarn install
-      # publint resolves the package `exports` against the packed tarball, which
-      # references ./dist/*. Reuse the build job's output instead of rebuilding.
-      - uses: actions/download-artifact@v8
-        with:
-          name: dist
-          path: dist
+      - run: yarn build
       - run: yarn publint
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index f3a585e..4feb337 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -23,15 +23,19 @@ jobs:
           cache: yarn
       - run: yarn install
       - run: yarn lint:check
-      - run: yarn typecheck
       - run: yarn build
       - run: yarn publint
-      - name: Verify tag matches package.json
+      - name: Verify tag matches package versions
         run: |
-          PKG_VERSION=$(node -p "require('./package.json').version")
           TAG_VERSION="${GITHUB_REF_NAME#v}"
-          if [ "$PKG_VERSION" != "$TAG_VERSION" ]; then
-            echo "Version mismatch: package.json=$PKG_VERSION, tag=$TAG_VERSION"
-            exit 1
-          fi
-      - run: npm publish --provenance --access public
+          for pkg in common server; do
+            PKG_VERSION=$(node -p "require('./packages/${pkg}/package.json').version")
+            if [ "$PKG_VERSION" != "$TAG_VERSION" ]; then
+              echo "Version mismatch in ${pkg}: package.json=$PKG_VERSION, tag=$TAG_VERSION"
+              exit 1
+            fi
+          done
+      - name: Publish @proof.com/proof-vc-common
+        run: npm publish -w packages/common --provenance --access public --no-package-lock
+      - name: Publish @proof.com/proof-vc-server
+        run: npm publish -w packages/server --provenance --access public --no-package-lock
diff --git a/.gitignore b/.gitignore
index 80184fa..33d54c3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 # Build artifacts
 dist/
+*.tsbuildinfo
 
 # Dependency artifacts
 node_modules/
diff --git a/.prettierignore b/.prettierignore
index 60239af..1aa9374 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -1 +1,2 @@
 .yarn/
+**/dist/
diff --git a/CLAUDE.md b/CLAUDE.md
index 177cbf6..f99c352 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -1,64 +1,85 @@
-# Proof VC Common - AI Assistant Guide
+# Proof VC - AI Assistant Guide
 
-Dual-target ESM TypeScript library `@proof.com/proof-vc-common`. Browser entry exposes `init` + `getAuthorizationRequestURL` (zero runtime deps). Node entry adds `verify` + `verifyVPToken` (SD-JWT verification, X.509 chain validation against an embedded trust root).
+A Yarn 4 monorepo publishing two ESM TypeScript packages:
+
+- **`@proof.com/proof-vc-common`** (`packages/common`) — public/frontend, runs in the browser **and** Node, **zero runtime deps**. Builds OID4VP Authorization Request URLs (`createClient` / `buildAuthorizationUrl`) and reads the `vp_token` from the redirect (`parseAuthorizationResponse`). No secrets, no `nonce` generation, no transaction data.
+- **`@proof.com/proof-vc-server`** (`packages/server`) — privileged/backend, **Node only**. Adds `verify` / `verifyVPToken` (SD-JWT-VC verification, X.509 chain validation against an embedded trust root), Pushed Authorization Requests, transaction data, and DC API requests. Depends on `proof-vc-common` and **re-exports it**, so backend integrators need one import. Yarn links it locally via transparent workspaces.
+
+`server` reuses `common`'s URL/param builders via the `@proof.com/proof-vc-common/internal` subpath export (server-only; not public frontend surface).
 
 ## Hard Rules
 
-1. **No `node:*`, `@sd-jwt/*`, `@owf/*`, or other runtime imports from anything reachable from `src/index.browser.ts`.** Type-only imports (`import type` / `export type *`) are safe — `verbatimModuleSyntax: true` erases them.
+1. **`packages/common` must stay pure.** No `node:*`, `@sd-jwt/*`, `@owf/*`, or other runtime imports from anything reachable from `packages/common/src/index.ts` or `packages/common/src/internal.ts`. Type-only imports (`import type` / `export type *`) are safe — `verbatimModuleSyntax: true` erases them. Verify after build (see Package Boundaries).
 2. **Prompt before publishing.** Never bump version, push tags, create a Release, or trigger the publish workflow without explicit confirmation. Publishes are permanent.
 3. **Run `yarn check-all` before any commit or push.** Composes format, lint, typecheck, publint.
 4. **Keep `yarn publint` on `--pack npm`.** `--pack auto` picks yarn-1 mode and reports false-positive errors.
 5. **Keep `engines.node` at `>=22.0.0` and keep the CI `test-matrix` covering that floor.** Node 22 is the oldest maintained LTS (Node 20 is EOL; `@sd-jwt/*` needs 20+). `>=22` is a lower bound, so it still allows 24 and newer. The floor is checked at runtime by the `test-matrix` job (`yarn test` on Node 22 and 24); `@types/node` tracks the dev runtime (24, from `.node-version`), not the floor. Invariant: the `test-matrix` low entry must equal the `engines.node` floor, so raise the floor by bumping both together. If you drop the matrix, pin `@types/node` to the floor major so typecheck guards it instead.
 6. **Never use `eslint-disable` as a workaround.** If a lint rule fires, fix the underlying code or surface the rule to the user for a config decision — do not silence it inline. Same applies to `@ts-ignore` / `@ts-expect-error` and other suppression comments.
 
-## Browser Graph
+## Package Boundaries
+
+Versioning is **lockstep**: both packages always share one version, published together from one GitHub Release.
 
-Browser-runtime files (reachable from `src/index.browser.ts`):
+`packages/common/src` (browser + Node, zero deps):
 
-- `src/index.browser.ts`
-- `src/vc_presentation.browser.ts`
-- `src/presentation/base_client.ts`
-- `src/transaction_data.ts`
-- `src/dcql.ts`
-- `src/constants.ts`
-- `src/types.ts` (type-only, erased at emit)
+- `index.ts` (public entry), `internal.ts` (server-only helpers)
+- `client.ts` — `createClient`, `buildAuthorizationUrl`, `parseAuthorizationResponse`, and the shared param/URL builders
+- `dcql.ts`, `constants.ts`, `types.ts` (shared wire types — the single source of truth; server imports & re-exports them)
 
-Everything else under `src/` is Node-side. Verify after build:
+`packages/server/src` (Node only):
+
+- `index.ts` — `export * from "@proof.com/proof-vc-common"` then the server surface (its `createClient` intentionally shadows the frontend one)
+- `client.ts` — server `createClient` (PAR, `transactionData`, `dcApiRequest`); `authorizationUrl` is `async` (PAR fetches)
+- `verifier.ts` — `createVerifier` → `verify` / `verifyVPToken`
+- `transaction_data.ts`, `proof_credentials.ts`, `proof_credential_factory.ts`, `utils.ts`, `types.ts` (`ProofCredential`/`VPToken`/`TrustRoot`), `certificates/**`
+
+Verify `common` stays free of runtime leaks after build:
 
 ```bash
-grep -lE '(jose|@sd-jwt|@owf|node:)' \
-  dist/index.browser.js dist/vc_presentation.browser.js \
-  dist/presentation/base_client.js dist/transaction_data.js \
-  dist/dcql.js dist/constants.js dist/types.js
+grep -lE '(jose|@sd-jwt|@owf|node:)' packages/common/dist/*.js
 # Must match nothing.
 ```
 
 ## Essential Commands
 
-| Command             | Purpose                                      |
-| ------------------- | -------------------------------------------- |
-| `yarn check-all`    | Full check: format, lint, typecheck, publint |
-| `yarn build`        | `tsc` emit to `dist/`                        |
-| `yarn typecheck`    | `tsc --noEmit`                               |
-| `yarn lint:check`   | eslint, no fix                               |
-| `yarn lint`         | `eslint --fix`                               |
-| `yarn format:check` | `prettier --check`                           |
-| `yarn format`       | `prettier --write`                           |
-| `yarn publint`      | `publint --pack npm` (keep the flag)         |
+Run from the repo root. Use `corepack yarn …` (or just `yarn`, with Corepack enabled).
+
+| Command             | Purpose                                                                            |
+| ------------------- | ---------------------------------------------------------------------------------- |
+| `yarn check-all`    | Full check: format, lint, build, publint                                           |
+| `yarn build`        | `tsc -b` (project references; builds common then server; errors on any type error) |
+| `yarn test`         | `yarn workspaces foreach` run tests (each self-builds)                             |
+| `yarn lint:check`   | eslint, no fix                                                                     |
+| `yarn lint`         | `eslint --fix`                                                                     |
+| `yarn format:check` | `prettier --check`                                                                 |
+| `yarn format`       | `prettier --write`                                                                 |
+| `yarn publint`      | publint over both publishable packages (`--pack npm`)                              |
+
+Installs are immutable by default (`.yarnrc.yml`). When changing dependencies or workspaces, run `yarn install --no-immutable` to update `yarn.lock`, then commit it.
+
+## Package manager (Yarn for dev, npm only for release)
+
+- **Yarn 4 (Corepack)** runs everything day-to-day: `install`, `build`, `test`, `lint`, `format`, `publint`, `check-all`. `yarn.lock` is the only lockfile.
+- **npm is used only in the release path** — `npm version … --workspaces` (bump) and `npm publish -w … --provenance` (publish) — for OIDC provenance / trusted publishing and the `-w` workspace publish. Always pass `--no-package-lock` so npm doesn't drop a `package-lock.json` into this Yarn-only repo.
+- **Don't run `npm install` / `npm ci` (or bare `npm version` / `npm publish`) locally outside the release flow.** npm's reify rewrites `node_modules` in a way that breaks Yarn's per-workspace `PATH` (symptom: workspace scripts fail with `command not found: tsc` / `publint`); recover with a fresh `yarn install`.
+- Each publishable package declares its script tools (`typescript`, `publint`) as devDependencies so `yarn workspace <pkg> <script>` (and `cd packages/<pkg> && yarn <script>`) work standalone — Yarn only exposes a workspace's own deps on its script `PATH`.
 
 ## TypeScript Conventions
 
 - `verbatimModuleSyntax: true` — use `import type` / `export type`.
 - `noUncheckedIndexedAccess: true` — indexing returns `T | undefined`; use `!` only when access is guaranteed safe.
 - `exactOptionalPropertyTypes: true` — spread optional fields conditionally: `...(state !== undefined && { state })`.
-- Local imports use the `.ts` extension (`rewriteRelativeImportExtensions` rewrites to `.js` on emit).
+- Local imports (within a package) use the `.ts` extension (`rewriteRelativeImportExtensions` rewrites to `.js` on emit).
+- Cross-package imports use the bare specifier (`@proof.com/proof-vc-common` / `…/internal`), resolved through the workspace symlink to the built `dist`.
 - Wire-level types use snake_case to match the JSON wire format.
+- Throw `Error` instances, not bare strings.
+- Shared config is in `tsconfig.base.json`; each package's `tsconfig.json` sets `rootDir`/`outDir`/`lib`/`types` and (server) `references`.
 
 ## Recipes
 
 ### Add a new EC algorithm
 
-In `src/presentation/node_client.ts`:
+In `packages/server/src/verifier.ts`:
 
 1. Import the helper from `@owf/crypto`.
 2. Add to `VERIFIERS` — `SupportedAlg` derives from `keyof typeof VERIFIERS` automatically.
@@ -66,13 +87,13 @@ In `src/presentation/node_client.ts`:
 
 ### Add a new transaction-data template
 
-In `src/transaction_data.ts`:
+In `packages/server/src/transaction_data.ts`:
 
 1. Add the URN literal to `TX_DATA_TYPE` (keep `as const`).
 2. Define payload and envelope types (use the `Envelope<T, P>` helper).
 3. Add the variant to the `TransactionData` union.
 4. Add a factory to the `transactionData` namespace.
-5. Re-export the new type names from `src/index.browser.ts` and `src/index.node.ts`.
+5. Re-export the new type names from `packages/server/src/index.ts`.
 
 `encodeTransactionData()` operates on the union — no encoder changes.
 
@@ -80,23 +101,26 @@ In `src/transaction_data.ts`:
 
 Prompt before publishing (Hard Rule 2).
 
-- **Auth**: npm Trusted Publishing via OIDC (no `NPM_TOKEN`).
-- **Trigger**: GitHub Release published → `.github/workflows/publish.yml`.
-- **Registry**: https://www.npmjs.com/package/@proof.com/proof-vc-common
+- **Auth**: npm Trusted Publishing via OIDC (no `NPM_TOKEN`), configured per package. `@proof.com/proof-vc-server` is a new package — confirm its trusted-publisher config exists on npm before the first release.
+- **Trigger**: GitHub Release published → `.github/workflows/publish.yml`, which publishes **both** packages with `npm publish -w <pkg> --provenance --access public --no-package-lock`, common first.
+- **Registries**: https://www.npmjs.com/package/@proof.com/proof-vc-common and https://www.npmjs.com/package/@proof.com/proof-vc-server
 
 ### Release flow (after user confirms)
 
-`main` is branch-protected: direct pushes are rejected. Bump on a branch, merge the PR, then create the Release against the exact merged commit SHA.
+`main` is branch-protected: direct pushes are rejected. Bump both packages on a branch, merge the PR, then create the Release against the exact merged commit SHA.
 
-1. Bump on a branch (no auto-tag from npm — the tag is created by `gh release create` in step 4):
+1. Bump on a branch (the tag is created by `gh release create` in step 4):
    ```bash
    git switch -c release-X.Y.Z origin/main
-   npm version patch --no-git-tag-version          # or minor / major; writes package.json only
+   npm version X.Y.Z --workspaces --no-git-tag-version --no-package-lock
+   npm pkg set "dependencies[@proof.com/proof-vc-common]=X.Y.Z" -w packages/server --no-package-lock
+   yarn install --no-immutable   # refresh yarn.lock for the bumped versions/range
    git commit -am "Release X.Y.Z"
    git push -u origin release-X.Y.Z
    ```
+   `npm version` bumps each package's `version`; the `npm pkg set` step then pins server's `@proof.com/proof-vc-common` dependency to the exact version being released, so server always ships against the latest common. `yarn install --no-immutable` refreshes `yarn.lock` (the version/range changes invalidate it) so the immutable CI install in `publish.yml` passes — commit it with the release.
 2. Open a PR. Approve and merge in the GitHub UI.
-3. Locate the merged commit SHA on `main` by grepping for the release commit subject:
+3. Locate the merged commit SHA on `main`:
    ```bash
    git fetch origin main
    SHA=$(git log origin/main --grep='Release X.Y.Z' --format=%H -n 1)
@@ -108,16 +132,12 @@ Prompt before publishing (Hard Rule 2).
    gh release create vX.Y.Z --target "$SHA" --generate-notes
    ```
 
-The Release triggers `publish.yml`: check suite → tag must match `package.json` → `npm publish --provenance --access public`.
+The Release triggers `publish.yml`: checks → tag must match both `package.json` versions → publish both with provenance.
 
 Never `git push --follow-tags` to `main`: the commit is rejected but the tag still pushes, stranding it on an unmerged commit. Delete a stray tag with `git push --delete origin vX.Y.Z`.
 
-## Tooling (Yarn 4)
-
-- Yarn is pinned via `packageManager: yarn@4.17.0` (`.yarn/releases/yarn-4.17.0.cjs`). Run `corepack enable` so the project yarn is used; CI does the same.
-- `.yarnrc.yml` config: `nodeLinker: node-modules`, immutable installs (`enableImmutableInstalls: true` - no `--frozen-lockfile` needed), `enableScripts: false` (no postinstall scripts - a dep needing a build step at install won't run it), `npmMinimalAgeGate: 1w` (deps published <1 week ago won't install; matches the dependabot 7-day cooldown).
-- `yarn.lock` is the only lockfile.
-
 ## Notes
 
+- Yarn 4 via Corepack, pinned by `packageManager` (`.yarn/releases/yarn-4.17.0.cjs`). `.yarnrc.yml`: `nodeLinker: node-modules`, immutable installs, `enableScripts: false`, `npmMinimalAgeGate: 1w`.
+- The root `package.json` is private (`proof-vc-workspace`) and is not published.
 - Scope is `@proof.com` (with the dot), not `@proof`.
diff --git a/README.md b/README.md
index 9028d3b..69d4921 100644
--- a/README.md
+++ b/README.md
@@ -4,12 +4,15 @@
 
 _A digital passport. Verified once, usable everywhere._
 
-Read our [documentation](https://dev.proof.com/docs/digital-credentials-overview) or [try it](https://demo.next.proof.com)!
+Read our [documentation](https://dev.proof.com/docs/digital-credentials-overview) or [try it](https://try.proof.com)!
 
 ## Table of Contents
 
+- [Packages](#packages)
 - [Installation](#installation)
 - [Getting Started](#getting-started)
+  - [Client Side](#client-side)
+  - [Server Side](#server-side)
   - [Response Modes](#response-modes)
   - [Pushed Authorization Requests](#pushed-authorization-requests)
 - [Verifiable Credential Presentation](#verifiable-credential-presentation)
@@ -23,50 +26,125 @@ Read our [documentation](https://dev.proof.com/docs/digital-credentials-overview
 - [Documentation](#documentation)
 - [Contributing](#contributing)
 
+## Packages
+
+| Package                                             | Runtime             | Usage                                                                                                      | Runtime deps |
+| --------------------------------------------------- | ------------------- | ---------------------------------------------------------------------------------------------------------- | ------------ |
+| **[`@proof.com/proof-vc-common`](packages/common)** | browser **or** Node | Request a Verifiable Presentation                                                                          | **0** ✅     |
+| **[`@proof.com/proof-vc-server`](packages/server)** | Node                | `proof-vc-common` **plus** Presentation Verification, Pushed Authorization Requests, Transaction Templates | sd-jwt, owf  |
+
 ## Installation
 
+Browser / Node:
+
 ```
 npm install @proof.com/proof-vc-common
 ```
 
-The library provides 2 distinct browser and Node.js distributions, see [package.json](package.json) `exports`. The browser distribution has **0 dependencies** :white_check_mark:
+Node:
 
-## Getting Started
+```
+npm install @proof.com/proof-vc-server
+```
 
 Proof implements the [OpenID for Verifiable Presentations 1.0](https://openid.net/specs/openid-4-verifiable-presentations-1_0.html) specification.
 [Setup an OAuth Application](https://dev.proof.com/docs/oauth-client-credentials) in your Proof account to get your `client_id`.
 
-Initialize the library at the start of your application:
+## Getting Started
+
+### Client Side
+
+You can request a Verifiable Presentation in the browser by using `createClient` and `authorizationUrl` to craft an Authorization Request URL.
+Either `fragment` or `direct_post` [Response Mode](#response-modes) are supported (defaults to `fragment`).
+
+- if using `fragment`, at the callback URI, use `parseAuthorizationResponse` to extract the `vp_token` from it and send it to your verification endpoint
+- if using `direct_post`, the `vp_token` is sent directly to your verification endpoint
 
 ```javascript
-import { init } from "@proof.com/proof-vc-common";
+import {
+  createClient,
+  parseAuthorizationResponse,
+} from "@proof.com/proof-vc-common";
 
-init({
+const proof = createClient({
   environment: "sandbox",
   clientId: "verifier-demo",
+  callbackUri: "https://example.com/verify_vp_token",
+});
+
+button.onclick = () => {
+  window.location.href = proof.authorizationUrl({
+    nonce: "3e8e4918-e9fb-453a-a538-81152be15c1b",
+    scope: "urn:proof:params:scope:verifiable-credentials:basic",
+  });
+};
+
+const response = parseAuthorizationResponse(); // reads window.location.hash
+if (response) {
+  await fetch("/verify_vp_token", {
+    method: "POST",
+    body: JSON.stringify(response),
+  });
+}
+```
+
+You can also use `buildAuthorizationUrl` to provide all the Authorization Request parameters at once:
+
+```javascript
+import { buildAuthorizationUrl } from "@proof.com/proof-vc-common";
+
+window.location.href = buildAuthorizationUrl({
+  environment: "sandbox",
+  clientId: "verifier-demo",
+  callbackUri: "https://example.com/verify_vp_token",
+  nonce: "3e8e4918-e9fb-453a-a538-81152be15c1b",
+  scope: "urn:proof:params:scope:verifiable-credentials:basic",
+});
+```
+
+### Server Side
+
+You can request a Verifiable Presentation from our backend by using `createClient` and `authorizationUrl` to craft an Authorization Request URL.
+Either `fragment` or `direct_post` [Response Mode](#response-modes) are supported (defaults to `fragment`).
+
+With [`@proof.com/proof-vc-server`](packages/server) you can also use [Pushed Authorization Requests](#pushed-authorization-requests) and [Transaction Templates](#transaction-templates).
+
+```javascript
+import { createClient } from "@proof.com/proof-vc-server";
+
+const proof = createClient({
+  environment: "sandbox",
+  clientId: "verifier-demo",
+  callbackUri: "https://example.com/verify_vp_token",
   responseMode: "direct_post",
-  callbackUri: "http://localhost/verify_vp_token",
+});
+
+const redirect = await proof.authorizationUrl({
+  nonce: "3e8e4918-e9fb-453a-a538-81152be15c1b",
+  scope: "urn:proof:params:scope:verifiable-credentials:basic",
+  state: "6A2B4CD830",
+  loginHint: "frodo.baggins@theshire",
 });
 ```
 
 ### Response Modes
 
-Proof supports `fragment` and `direct_post` response modes.
+Proof supports `fragment` and `direct_post` response modes (default `fragment`).
 
 #### fragment
 
-Using `fragment` the `vp_token` is returned as a fragment of the `callbackUri` when the user is 302 redirected from Proof to your website.
+Using `fragment` the `vp_token` is returned as a fragment of the `callbackUri` when the user is 302 redirected from Proof to your website. Use `parseAuthorizationResponse()` in the browser to read it.
 
 ```
-GET http://localhost/verify_vp_token#vp_token=eyJwcm9vZl9pZF9...
+GET https://example.com/verify_vp_token#vp_token=eyJwcm9vZl9pZF9...
 ```
 
 #### direct_post
 
-Using `direct_post` the `vp_token` is returned in the JSON body of a POST request to the `callbackUri` from Proof to your website. See the [OID4VP specification](https://openid.net/specs/openid-4-verifiable-presentations-1_0.html#name-response-mode-direct_post) for more details.
+Using `direct_post` the `vp_token` is returned in the JSON body of a POST request to the `callbackUri` from Proof to your server. See the [OID4VP specification](https://openid.net/specs/openid-4-verifiable-presentations-1_0.html#name-response-mode-direct_post) for more details.
 
 ```
-POST http://localhost/verify_vp_token
+POST https://example.com/verify_vp_token
 { "vp_token": "eyJwcm9vZl9pZF9..." }
 ```
 
@@ -74,17 +152,24 @@ POST http://localhost/verify_vp_token
 
 Proof supports [Pushed Authorization Requests](https://datatracker.ietf.org/doc/html/rfc9126) (PAR).
 You may want to use this feature when using [Transaction Templates](#transaction-templates) to avoid hitting URL size limits.
-Note that PAR is available **only from the Node.js distribution**.
+PAR requires a `clientSecret` and is therefore available **only from `@proof.com/proof-vc-server`**.
 
 ```javascript
-init({
+import { createClient } from "@proof.com/proof-vc-server";
+
+const proof = createClient({
   environment: "sandbox",
   clientId: "caxdw5a7d",
   clientSecret: "…",
+  callbackUri: "https://example.com/verify_vp_token",
   responseMode: "direct_post",
-  callbackUri: "http://localhost/verify_vp_token",
   usePushedAuthorizationRequest: true,
 });
+
+const redirect = await proof.authorizationUrl({
+  nonce: "3e8e4918-e9fb-453a-a538-81152be15c1b",
+  scope: "urn:proof:params:scope:verifiable-credentials:basic",
+});
 ```
 
 ## Verifiable Credential Presentation
@@ -108,20 +193,7 @@ All attributes are selectively disclosable and will return `undefined` if the cl
 
 ### Request
 
-Request a Verifiable Credential Presentation with an [OAuth 2.0](https://datatracker.ietf.org/doc/html/rfc6749) Authorization Request:
-
-```javascript
-import { getAuthorizationRequestURL } from "@proof.com/proof-vc-common";
-
-const redirect = await getAuthorizationRequestURL({
-  nonce: "3e8e4918-e9fb-453a-a538-81152be15c1b",
-  scope: "urn:proof:params:scope:verifiable-credentials:basic",
-  state: "6A2B4CD830",
-  loginHint: "frodo.baggins@theshire",
-});
-
-window.location.href = redirect;
-```
+Request a Verifiable Credential Presentation with an [OAuth 2.0](https://datatracker.ietf.org/doc/html/rfc6749) Authorization Request. See [Frontend](#frontend-request-a-presentation) and [Backend](#backend-request-a-presentation) above for the two entry points.
 
 #### Scopes
 
@@ -138,15 +210,18 @@ Supported `scope` and their associated [Credential Type](#credential-type):
 _Transaction Templates_ allow you to bind specific data to a Verifiable Credential Presentation. Proof uses the [Transaction Data](https://openid.net/specs/openid-4-verifiable-presentations-1_0.html#name-transaction-data) parameter of the OID4VP specification.
 The data is shown to the user during the Presentation flow and the user signs it with a Key Binding JWT (KB-JWT). The KB-JWT is returned as part of the [Presentation](https://dev.proof.com/docs/sd-jwt-vc-format).
 
-The following _Transaction Templates_ are available:
+Transaction data is sensitive and is therefore attached **only from `@proof.com/proof-vc-server`**. The following _Transaction Templates_ are available:
 
 **urn:proof:params:vc:transaction-data:wire-instructions:v1**
 
 ```javascript
-import {
-  getAuthorizationRequestURL,
-  transactionData,
-} from "@proof.com/proof-vc-common";
+import { createClient, transactionData } from "@proof.com/proof-vc-server";
+
+const proof = createClient({
+  environment: "sandbox",
+  clientId: "verifier-demo",
+  callbackUri: "https://example.com/verify_vp_token",
+});
 
 const data = transactionData.wireInstructions({
   recipient: {
@@ -165,7 +240,7 @@ const data = transactionData.wireInstructions({
   currency: "USD",
   memo: "Invoice #2024-089",
 });
-const redirect = await getAuthorizationRequestURL({
+const redirect = await proof.authorizationUrl({
   nonce: "3e8e4918-e9fb-453a-a538-81152be15c1b",
   scope: "urn:proof:params:scope:verifiable-credentials:basic",
   state: "6A2B4CD830",
@@ -179,10 +254,13 @@ const redirect = await getAuthorizationRequestURL({
 **urn:proof:params:vc:transaction-data:payment-itemized:v1**
 
 ```javascript
-import {
-  getAuthorizationRequestURL,
-  transactionData,
-} from "@proof.com/proof-vc-common";
+import { createClient, transactionData } from "@proof.com/proof-vc-server";
+
+const proof = createClient({
+  environment: "sandbox",
+  clientId: "verifier-demo",
+  callbackUri: "https://example.com/verify_vp_token",
+});
 
 const data = transactionData.paymentItemized({
   title: "Drive Shaft",
@@ -193,7 +271,7 @@ const data = transactionData.paymentItemized({
     { quantity: 2, unit_cost: 11.4, label: "Fees" },
   ],
 });
-const redirect = await getAuthorizationRequestURL({
+const redirect = await proof.authorizationUrl({
   nonce: "3e8e4918-e9fb-453a-a538-81152be15c1b",
   scope: "urn:proof:params:scope:verifiable-credentials:basic",
   state: "6A2B4CD830",
@@ -207,10 +285,13 @@ const redirect = await getAuthorizationRequestURL({
 **urn:proof:params:vc:transaction-data:payment-mandate:v1**
 
 ```javascript
-import {
-  getAuthorizationRequestURL,
-  transactionData,
-} from "@proof.com/proof-vc-common";
+import { createClient, transactionData } from "@proof.com/proof-vc-server";
+
+const proof = createClient({
+  environment: "sandbox",
+  clientId: "verifier-demo",
+  callbackUri: "https://example.com/verify_vp_token",
+});
 
 const data = transactionData.paymentMandate({
   payment_instrument: {
@@ -228,7 +309,7 @@ const data = transactionData.paymentMandate({
   amount: 500,
   currency: "USD",
 });
-const redirect = await getAuthorizationRequestURL({
+const redirect = await proof.authorizationUrl({
   nonce: "3e8e4918-e9fb-453a-a538-81152be15c1b",
   scope: "urn:proof:params:scope:verifiable-credentials:basic",
   state: "6A2B4CD830",
@@ -239,15 +320,17 @@ const redirect = await getAuthorizationRequestURL({
 
 ### Verify
 
-Decode and verify a Verifiable Presentation's `vp_token` server-side:
+Verification runs server-side. Create a verifier bound to a trust root and reuse it.
+
+Decode and verify a Verifiable Presentation's `vp_token`:
 
 ```javascript
-import { init, verifyVPToken } from "@proof.com/proof-vc-common";
+import { createVerifier } from "@proof.com/proof-vc-server";
 
-init({ trustRoot: "production" });
+const verifier = createVerifier({ trustRoot: "production" });
 
 const vpToken = "eyJwcm9vZl9pZ...";
-const presentation = await verifyVPToken({ encodedVPToken: vpToken });
+const presentation = await verifier.verifyVPToken({ encodedVPToken: vpToken });
 const verifiableCredential = presentation["proof_id_default"][0];
 
 if (verifiableCredential.isOver18) {
@@ -260,12 +343,12 @@ if (verifiableCredential.isOver18) {
 Verify a single SD-JWT-VC:
 
 ```javascript
-import { init, verify } from "@proof.com/proof-vc-common";
+import { createVerifier } from "@proof.com/proof-vc-server";
 
-init({ trustRoot: "production" });
+const verifier = createVerifier({ trustRoot: "production" });
 
 const encodedSDJWT = "eyJraWQiOiI3...";
-const verifiableCredential = await verify({ encodedSDJWT });
+const verifiableCredential = await verifier.verify({ encodedSDJWT });
 
 if (verifiableCredential.isOver18) {
   purchaseItem();
@@ -279,7 +362,7 @@ if (verifiableCredential.isOver18) {
 Validating the `nonce` is out of scope of `verify` and `verifyVPToken`. The `nonce` signed in the Key Binding JWT is exposed on the returned credential and should be validated by the caller against the `nonce` sent in the [Request](#request):
 
 ```javascript
-const verifiableCredential = await verify({ encodedSDJWT });
+const verifiableCredential = await verifier.verify({ encodedSDJWT });
 
 if (
   verifiableCredential.getNonce() !== "3e8e4918-e9fb-453a-a538-81152be15c1b"
@@ -294,9 +377,9 @@ Proof's Verifiable Credentials are issued by our [Certificate Authority](https:/
 following the CA/B Forum Baseline Requirements for the Issuance and Management of Publicly-Trusted TLS Server Certificates published at https://www.cabforum.org.
 
 The Proof Root CA R1 Certificate is published at http://cert.proof.com/proof-root-ca-r1.crt and
-is also committed in this repository [proof-root-ca-r1.crt](src/certificates/trust_store/proof_root_ca_r1.ts).
+is also committed in this repository [proof-root-ca-r1.crt](packages/server/src/certificates/trust_store/proof_root_ca_r1.ts).
 
-The sandbox Root CA R1 Development certificate is also committed in this repository [proof-root-ca-r1-development.crt](src/certificates/trust_store/proof_root_ca_r1_development.ts) and used when `trustRoot: "development"`.
+The sandbox Root CA R1 Development certificate is also committed in this repository [proof-root-ca-r1-development.crt](packages/server/src/certificates/trust_store/proof_root_ca_r1_development.ts) and used when `trustRoot: "development"`.
 
 ## Documentation
 
diff --git a/eslint.config.mjs b/eslint.config.mjs
index a059729..a314f4c 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -2,7 +2,7 @@ import tseslint from "typescript-eslint";
 import unusedImports from "eslint-plugin-unused-imports";
 
 export default tseslint.config(
-  { ignores: ["dist/**"] },
+  { ignores: ["**/dist/**"] },
   ...tseslint.configs.recommended,
   {
     plugins: {
diff --git a/package.json b/package.json
index b4d2eb7..375280e 100644
--- a/package.json
+++ b/package.json
@@ -1,63 +1,23 @@
 {
-  "name": "@proof.com/proof-vc-common",
-  "version": "0.2.0",
-  "description": "A digital passport. Verified once, usable everywhere.",
-  "keywords": [
-    "VC",
-    "Verifiable Credentials",
-    "OID4VCI",
-    "OID4VCP",
-    "SD-JWT-VC",
-    "Selective Disclosures",
-    "Proof",
-    "Proof.com",
-    "OAuth"
-  ],
-  "homepage": "https://github.com/proof/proof-vc-common",
-  "bugs": "https://github.com/proof/proof-vc-common/issues",
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/proof/proof-vc-common.git"
-  },
+  "name": "proof-vc-workspace",
+  "version": "0.3.0",
+  "private": true,
   "license": "Apache-2.0",
   "author": "Jeremie Charrier <jeremie.charrier@proof.com>",
-  "sideEffects": false,
   "type": "module",
-  "exports": {
-    ".": {
-      "browser": {
-        "types": "./dist/index.browser.d.ts",
-        "default": "./dist/index.browser.js"
-      },
-      "node": {
-        "types": "./dist/index.node.d.ts",
-        "default": "./dist/index.node.js"
-      },
-      "default": {
-        "types": "./dist/index.node.d.ts",
-        "default": "./dist/index.node.js"
-      }
-    }
-  },
-  "files": [
-    "dist"
+  "workspaces": [
+    "packages/*"
   ],
   "scripts": {
-    "build": "tsc",
-    "check-all": "yarn format && yarn lint && yarn typecheck && yarn publint",
+    "build": "tsc -b",
+    "check-all": "yarn format && yarn lint && yarn build && yarn publint",
+    "clean": "tsc -b --clean",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "lint": "eslint . --fix",
     "lint:check": "eslint .",
-    "publint": "publint --pack npm",
-    "test": "tsc && node --test test/*.test.mjs",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "@owf/crypto": "^0.3.0",
-    "@owf/identity-common": "^0.3.0",
-    "@sd-jwt/core": "^0.19.0",
-    "@sd-jwt/sd-jwt-vc": "^0.19.0"
+    "publint": "yarn workspaces foreach --all --no-private run publint",
+    "test": "yarn workspaces foreach --all --no-private run test"
   },
   "devDependencies": {
     "@types/node": "^24.13.2",
@@ -72,8 +32,5 @@
   "packageManager": "yarn@4.17.0",
   "engines": {
     "node": ">=22.0.0"
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }
diff --git a/packages/common/package.json b/packages/common/package.json
new file mode 100644
index 0000000..650f72a
--- /dev/null
+++ b/packages/common/package.json
@@ -0,0 +1,55 @@
+{
+  "name": "@proof.com/proof-vc-common",
+  "version": "0.3.0",
+  "description": "A digital passport, verified once, usable everywhere.",
+  "keywords": [
+    "VC",
+    "Verifiable Credentials",
+    "OID4VCI",
+    "OID4VCP",
+    "SD-JWT-VC",
+    "Selective Disclosures",
+    "Proof",
+    "Proof.com",
+    "OAuth"
+  ],
+  "homepage": "https://github.com/proof/proof-vc-common",
+  "bugs": "https://github.com/proof/proof-vc-common/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/proof/proof-vc-common.git",
+    "directory": "packages/common"
+  },
+  "license": "Apache-2.0",
+  "author": "Jeremie Charrier <jeremie.charrier@proof.com>",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "default": "./dist/internal.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "publint": "publint --pack npm",
+    "test": "tsc -b && node --test test/*.test.mjs"
+  },
+  "devDependencies": {
+    "publint": "^0.3.21",
+    "typescript": "^6.0.3"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}
diff --git a/packages/common/src/client.ts b/packages/common/src/client.ts
new file mode 100644
index 0000000..fc8b1e3
--- /dev/null
+++ b/packages/common/src/client.ts
@@ -0,0 +1,63 @@
+import {
+  buildAuthorizationSearchParams,
+  authorizeUrlFromSearchParams,
+  type ClientConfig,
+  type AuthorizationRequestParams,
+} from "./internal.ts";
+
+export type { ClientConfig, AuthorizationRequestParams } from "./internal.ts";
+
+export type AuthorizationResponse = {
+  vpToken: string;
+  state?: string;
+};
+
+export interface VCClient {
+  authorizationUrl(params: AuthorizationRequestParams): string;
+}
+
+export function createClient(config: ClientConfig): VCClient {
+  return {
+    authorizationUrl(params: AuthorizationRequestParams): string {
+      const search = buildAuthorizationSearchParams(config, params);
+      return authorizeUrlFromSearchParams(config.environment, search);
+    },
+  };
+}
+
+export function buildAuthorizationUrl(
+  input: ClientConfig & AuthorizationRequestParams,
+): string {
+  const { environment, clientId, callbackUri, responseMode, ...params } = input;
+  const config: ClientConfig = {
+    environment,
+    clientId,
+    callbackUri,
+    ...(responseMode !== undefined && { responseMode }),
+  };
+  return createClient(config).authorizationUrl(
+    params as AuthorizationRequestParams,
+  );
+}
+
+export function parseAuthorizationResponse(
+  input?: string,
+): AuthorizationResponse | null {
+  let raw = input;
+  if (raw === undefined) {
+    if (typeof window === "undefined") {
+      return null;
+    }
+    raw =
+      window.location.hash.length > 1
+        ? window.location.hash
+        : window.location.search;
+  }
+  const search = new URLSearchParams(raw.replace(/^[#?]/, ""));
+  const vpToken = search.get("vp_token");
+  if (vpToken === null) {
+    return null;
+  }
+  const state = search.get("state");
+  return { vpToken, ...(state !== null && { state }) };
+}
diff --git a/src/constants.ts b/packages/common/src/constants.ts
similarity index 100%
rename from src/constants.ts
rename to packages/common/src/constants.ts
diff --git a/src/dcql.ts b/packages/common/src/dcql.ts
similarity index 100%
rename from src/dcql.ts
rename to packages/common/src/dcql.ts
diff --git a/packages/common/src/index.ts b/packages/common/src/index.ts
new file mode 100644
index 0000000..069dc24
--- /dev/null
+++ b/packages/common/src/index.ts
@@ -0,0 +1,30 @@
+export type {
+  Environment,
+  ResponseMode,
+  ResponseType,
+  Scope,
+  CredentialID,
+  CredentialType,
+  Format,
+} from "./types.ts";
+
+export { DEFAULT_CREDENTIAL_ID, PROOF_CREDENTIAL_V1_VCT } from "./constants.ts";
+
+export type {
+  DCQLQuery,
+  DCQLCredentialQuery,
+  DCQLCredentialQueryMeta,
+} from "./dcql.ts";
+export { DCQL_QUERY_BASIC } from "./dcql.ts";
+
+export type {
+  ClientConfig,
+  AuthorizationRequestParams,
+  AuthorizationResponse,
+  VCClient,
+} from "./client.ts";
+export {
+  createClient,
+  buildAuthorizationUrl,
+  parseAuthorizationResponse,
+} from "./client.ts";
diff --git a/packages/common/src/internal.ts b/packages/common/src/internal.ts
new file mode 100644
index 0000000..54758de
--- /dev/null
+++ b/packages/common/src/internal.ts
@@ -0,0 +1,79 @@
+import type {
+  Environment,
+  ResponseMode,
+  ResponseType,
+  Scope,
+} from "./types.ts";
+import type { DCQLQuery } from "./dcql.ts";
+
+export const OID4VP_URI = "/verifiable-credentials/v1/presentation";
+export const RESPONSE_TYPE: ResponseType = "vp_token";
+const DEFAULT_RESPONSE_MODE: ResponseMode = "fragment";
+
+export type ClientConfig = {
+  environment: Environment;
+  clientId: string;
+  callbackUri: string;
+  responseMode?: ResponseMode;
+};
+
+type BaseAuthorizationRequestParams = {
+  nonce: string;
+  state?: string;
+  loginHint?: string;
+};
+
+export type AuthorizationRequestParams = BaseAuthorizationRequestParams &
+  (
+    | { scope: Scope; dcqlQuery?: never }
+    | { dcqlQuery: DCQLQuery; scope?: never }
+  );
+
+export function resolveBaseUrl(environment: Environment): string {
+  switch (environment) {
+    case "localhost":
+      return "https://api.local.dev-notarize.com";
+    case "next":
+      return "https://api.next.proof.com";
+    case "staging":
+      return "https://api.staging.proof.com";
+    case "sandbox":
+      return "https://api.fairfax.proof.com";
+    case "production":
+      return "https://api.proof.com";
+  }
+}
+
+export function buildAuthorizationSearchParams(
+  config: ClientConfig,
+  params: AuthorizationRequestParams,
+): URLSearchParams {
+  const { scope, dcqlQuery, nonce, state, loginHint } = params;
+  if ((scope === undefined) === (dcqlQuery === undefined)) {
+    throw new Error(
+      "authorization request requires exactly one of `scope` or `dcqlQuery`",
+    );
+  }
+  const responseMode = config.responseMode ?? DEFAULT_RESPONSE_MODE;
+  return new URLSearchParams({
+    client_id: config.clientId,
+    response_mode: responseMode,
+    response_type: RESPONSE_TYPE,
+    ...(responseMode === "fragment" && { redirect_uri: config.callbackUri }),
+    ...(responseMode === "direct_post" && { response_uri: config.callbackUri }),
+    ...(scope !== undefined && { scope }),
+    ...(dcqlQuery !== undefined && { dcql_query: JSON.stringify(dcqlQuery) }),
+    nonce,
+    ...(state !== undefined && { state }),
+    ...(loginHint !== undefined && { login_hint: loginHint }),
+  });
+}
+
+export function authorizeUrlFromSearchParams(
+  environment: Environment,
+  search: URLSearchParams,
+): string {
+  const url = new URL(`${OID4VP_URI}/authorize`, resolveBaseUrl(environment));
+  url.search = search.toString();
+  return url.toString();
+}
diff --git a/src/types.ts b/packages/common/src/types.ts
similarity index 53%
rename from src/types.ts
rename to packages/common/src/types.ts
index 76c3b9a..da8908c 100644
--- a/src/types.ts
+++ b/packages/common/src/types.ts
@@ -1,25 +1,12 @@
-import type { SDJwt } from "@sd-jwt/core";
-
 export type Environment =
   | "localhost"
   | "next"
   | "staging"
   | "sandbox"
   | "production";
-export type TrustRoot = "development" | "production";
 export type ResponseMode = "fragment" | "direct_post";
 export type ResponseType = "vp_token";
 export type Scope = "urn:proof:params:scope:verifiable-credentials:basic";
 export type CredentialID = "proof_id_default";
 export type CredentialType = "ProofCredentialV1";
 export type Format = "dc+sd-jwt";
-
-export interface ProofCredential {
-  credentialType(): CredentialType;
-  format(): Format;
-  getClaims(): Record<string, unknown>;
-  getSDJWT(): SDJwt;
-  getNonce(): string | undefined;
-}
-
-export type VPToken = Record<CredentialID, ProofCredential[]>;
diff --git a/packages/common/test/authorization.test.mjs b/packages/common/test/authorization.test.mjs
new file mode 100644
index 0000000..9a50431
--- /dev/null
+++ b/packages/common/test/authorization.test.mjs
@@ -0,0 +1,92 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  createClient,
+  buildAuthorizationUrl,
+  parseAuthorizationResponse,
+  DCQL_QUERY_BASIC,
+} from "../dist/index.js";
+
+const CONFIG = {
+  environment: "production",
+  clientId: "client-abc",
+  callbackUri: "https://merchant.example.com/callback",
+};
+
+test("createClient builds a scope-based authorize URL (fragment default)", () => {
+  const url = new URL(
+    createClient(CONFIG).authorizationUrl({
+      nonce: "n-123",
+      scope: "urn:proof:params:scope:verifiable-credentials:basic",
+    }),
+  );
+  assert.equal(url.origin, "https://api.proof.com");
+  assert.equal(
+    url.pathname,
+    "/verifiable-credentials/v1/presentation/authorize",
+  );
+  assert.equal(url.searchParams.get("client_id"), "client-abc");
+  assert.equal(url.searchParams.get("response_mode"), "fragment");
+  assert.equal(url.searchParams.get("response_type"), "vp_token");
+  assert.equal(
+    url.searchParams.get("redirect_uri"),
+    "https://merchant.example.com/callback",
+  );
+  assert.equal(url.searchParams.get("nonce"), "n-123");
+  assert.equal(
+    url.searchParams.get("scope"),
+    "urn:proof:params:scope:verifiable-credentials:basic",
+  );
+});
+
+test("direct_post uses response_uri instead of redirect_uri", () => {
+  const url = new URL(
+    createClient({ ...CONFIG, responseMode: "direct_post" }).authorizationUrl({
+      nonce: "n-1",
+      dcqlQuery: DCQL_QUERY_BASIC,
+    }),
+  );
+  assert.equal(
+    url.searchParams.get("response_uri"),
+    "https://merchant.example.com/callback",
+  );
+  assert.equal(url.searchParams.get("redirect_uri"), null);
+  assert.equal(
+    url.searchParams.get("dcql_query"),
+    JSON.stringify(DCQL_QUERY_BASIC),
+  );
+});
+
+test("buildAuthorizationUrl matches createClient for the same inputs", () => {
+  const params = {
+    nonce: "n-9",
+    scope: "urn:proof:params:scope:verifiable-credentials:basic",
+    state: "s-1",
+  };
+  assert.equal(
+    buildAuthorizationUrl({ ...CONFIG, ...params }),
+    createClient(CONFIG).authorizationUrl(params),
+  );
+});
+
+test("rejects supplying both scope and dcqlQuery", () => {
+  assert.throws(
+    () =>
+      createClient(CONFIG).authorizationUrl({
+        nonce: "n",
+        scope: "urn:proof:params:scope:verifiable-credentials:basic",
+        dcqlQuery: DCQL_QUERY_BASIC,
+      }),
+    /exactly one of `scope` or `dcqlQuery`/,
+  );
+});
+
+test("parseAuthorizationResponse reads vp_token and state from a fragment", () => {
+  const parsed = parseAuthorizationResponse("#vp_token=abc123&state=xyz");
+  assert.deepEqual(parsed, { vpToken: "abc123", state: "xyz" });
+});
+
+test("parseAuthorizationResponse returns null when no vp_token is present", () => {
+  assert.equal(parseAuthorizationResponse("#error=access_denied"), null);
+});
diff --git a/packages/common/tsconfig.json b/packages/common/tsconfig.json
new file mode 100644
index 0000000..d8692ed
--- /dev/null
+++ b/packages/common/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "lib": ["ESNext", "DOM"],
+    "types": []
+  },
+  "include": ["src"]
+}
diff --git a/packages/server/package.json b/packages/server/package.json
new file mode 100644
index 0000000..ed332a2
--- /dev/null
+++ b/packages/server/package.json
@@ -0,0 +1,57 @@
+{
+  "name": "@proof.com/proof-vc-server",
+  "version": "0.3.0",
+  "description": "A digital passport, verified once, usable everywhere.",
+  "keywords": [
+    "VC",
+    "Verifiable Credentials",
+    "OID4VCI",
+    "OID4VCP",
+    "SD-JWT-VC",
+    "Selective Disclosures",
+    "Proof",
+    "Proof.com",
+    "OAuth"
+  ],
+  "homepage": "https://github.com/proof/proof-vc-common",
+  "bugs": "https://github.com/proof/proof-vc-common/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/proof/proof-vc-common.git",
+    "directory": "packages/server"
+  },
+  "license": "Apache-2.0",
+  "author": "Jeremie Charrier <jeremie.charrier@proof.com>",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "publint": "publint --pack npm",
+    "test": "tsc -b && node --test test/*.test.mjs"
+  },
+  "dependencies": {
+    "@owf/crypto": "^0.3.0",
+    "@owf/identity-common": "^0.3.0",
+    "@proof.com/proof-vc-common": "^0.3.0",
+    "@sd-jwt/core": "^0.19.0",
+    "@sd-jwt/sd-jwt-vc": "^0.19.0"
+  },
+  "devDependencies": {
+    "publint": "^0.3.21",
+    "typescript": "^6.0.3"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}
diff --git a/src/certificates/chain_validator.ts b/packages/server/src/certificates/chain_validator.ts
similarity index 64%
rename from src/certificates/chain_validator.ts
rename to packages/server/src/certificates/chain_validator.ts
index 448d5ef..7bb4f93 100644
--- a/src/certificates/chain_validator.ts
+++ b/packages/server/src/certificates/chain_validator.ts
@@ -5,7 +5,7 @@ export function verifyChain(
   root: X509Certificate,
 ): void {
   if (chain.length === 0) {
-    throw "verifyChain: empty chain";
+    throw new Error("verifyChain: empty chain");
   }
 
   const full = [...chain, root];
@@ -18,20 +18,20 @@ export function verifyChain(
     const validFrom = new Date(cert.validFromDate);
     const validTo = new Date(cert.validToDate);
     if (now < validFrom || now > validTo) {
-      throw `Certificate at index ${i} is expired or not yet valid`;
+      throw new Error(`Certificate at index ${i} is expired or not yet valid`);
     }
     if (!cert.checkIssued(issuer)) {
-      throw `Certificate at index ${i} not issued by next in chain`;
+      throw new Error(`Certificate at index ${i} not issued by next in chain`);
     }
     if (!cert.verify(issuer.publicKey)) {
-      throw `Certificate at index ${i} has invalid signature`;
+      throw new Error(`Certificate at index ${i} has invalid signature`);
     }
   }
 
   if (now > new Date(root.validToDate)) {
-    throw "Root certificate expired";
+    throw new Error("Root certificate expired");
   }
   if (!root.verify(root.publicKey)) {
-    throw "Root is not self-signed";
+    throw new Error("Root is not self-signed");
   }
 }
diff --git a/src/certificates/trust_store/index.ts b/packages/server/src/certificates/trust_store/index.ts
similarity index 100%
rename from src/certificates/trust_store/index.ts
rename to packages/server/src/certificates/trust_store/index.ts
diff --git a/src/certificates/trust_store/proof_root_ca_r1.ts b/packages/server/src/certificates/trust_store/proof_root_ca_r1.ts
similarity index 100%
rename from src/certificates/trust_store/proof_root_ca_r1.ts
rename to packages/server/src/certificates/trust_store/proof_root_ca_r1.ts
diff --git a/src/certificates/trust_store/proof_root_ca_r1_development.ts b/packages/server/src/certificates/trust_store/proof_root_ca_r1_development.ts
similarity index 100%
rename from src/certificates/trust_store/proof_root_ca_r1_development.ts
rename to packages/server/src/certificates/trust_store/proof_root_ca_r1_development.ts
diff --git a/packages/server/src/client.ts b/packages/server/src/client.ts
new file mode 100644
index 0000000..3b53dc5
--- /dev/null
+++ b/packages/server/src/client.ts
@@ -0,0 +1,131 @@
+import {
+  OID4VP_URI,
+  RESPONSE_TYPE,
+  resolveBaseUrl,
+  buildAuthorizationSearchParams,
+  authorizeUrlFromSearchParams,
+  type ClientConfig,
+  type AuthorizationRequestParams,
+} from "@proof.com/proof-vc-common/internal";
+import type { DCQLQuery } from "@proof.com/proof-vc-common";
+import {
+  encodeTransactionData,
+  type TransactionData,
+} from "./transaction_data.ts";
+
+export type ServerClientConfig = ClientConfig & {
+  clientSecret?: string;
+  usePushedAuthorizationRequest?: boolean;
+};
+
+export type ServerAuthorizationRequestParams = AuthorizationRequestParams & {
+  transactionData?: TransactionData | string;
+};
+
+export type DCAPIAuthorizationRequestParams = {
+  dcqlQuery: DCQLQuery;
+  nonce: string;
+  transactionData?: TransactionData | string;
+};
+
+export type AuthorizationRequest = {
+  response_type: typeof RESPONSE_TYPE;
+  response_mode: "dc_api";
+  nonce: string;
+  dcql_query: DCQLQuery;
+  transaction_data?: string[];
+};
+
+export interface ServerVCClient {
+  authorizationUrl(params: ServerAuthorizationRequestParams): Promise<string>;
+  dcApiRequest(params: DCAPIAuthorizationRequestParams): AuthorizationRequest;
+}
+
+function encodeTxData(
+  transactionData: TransactionData | string | undefined,
+): string | undefined {
+  return typeof transactionData === "object"
+    ? encodeTransactionData(transactionData)
+    : transactionData;
+}
+
+export function createClient(config: ServerClientConfig): ServerVCClient {
+  function buildParams(
+    params: ServerAuthorizationRequestParams,
+  ): URLSearchParams {
+    const search = buildAuthorizationSearchParams(config, params);
+    if (config.clientSecret !== undefined) {
+      search.set("client_secret", config.clientSecret);
+    }
+    const encoded = encodeTxData(params.transactionData);
+    if (encoded !== undefined) {
+      search.set("transaction_data", encoded);
+    }
+    return search;
+  }
+
+  async function pushAuthorizationRequest(
+    search: URLSearchParams,
+  ): Promise<string> {
+    if (config.clientSecret === undefined) {
+      throw new Error(
+        "pushed authorization requests require `clientSecret` in the client config",
+      );
+    }
+    const parURL = new URL(
+      `${OID4VP_URI}/par`,
+      resolveBaseUrl(config.environment),
+    ).toString();
+    const response = await fetch(parURL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: search.toString(),
+    });
+    const data = (await response.json()) as Record<string, string | undefined>;
+
+    if (!response.ok) {
+      throw new Error(`${data["error"]}: ${data["error_description"]}`);
+    }
+    const requestUri = data["request_uri"];
+    if (typeof requestUri !== "string") {
+      throw new Error(
+        "pushed authorization request response missing `request_uri`",
+      );
+    }
+
+    const authorizeURL = new URL(
+      `${OID4VP_URI}/authorize`,
+      resolveBaseUrl(config.environment),
+    );
+    authorizeURL.search = new URLSearchParams({
+      client_id: config.clientId,
+      request_uri: requestUri,
+    }).toString();
+    return authorizeURL.toString();
+  }
+
+  return {
+    async authorizationUrl(
+      params: ServerAuthorizationRequestParams,
+    ): Promise<string> {
+      const search = buildParams(params);
+      return config.usePushedAuthorizationRequest === true
+        ? pushAuthorizationRequest(search)
+        : authorizeUrlFromSearchParams(config.environment, search);
+    },
+    dcApiRequest({
+      dcqlQuery,
+      nonce,
+      transactionData,
+    }: DCAPIAuthorizationRequestParams): AuthorizationRequest {
+      const encoded = encodeTxData(transactionData);
+      return {
+        response_type: RESPONSE_TYPE,
+        response_mode: "dc_api",
+        nonce,
+        dcql_query: dcqlQuery,
+        ...(encoded !== undefined && { transaction_data: [encoded] }),
+      };
+    },
+  };
+}
diff --git a/src/index.node.ts b/packages/server/src/index.ts
similarity index 56%
rename from src/index.node.ts
rename to packages/server/src/index.ts
index 9e0d856..6cd9c68 100644
--- a/src/index.node.ts
+++ b/packages/server/src/index.ts
@@ -1,4 +1,8 @@
-export type * from "./types.ts";
+export * from "@proof.com/proof-vc-common";
+
+export { ProofCredentialV1 } from "./proof_credentials.ts";
+export type { ProofCredential, VPToken, TrustRoot } from "./types.ts";
+
 export type {
   TransactionData,
   WireInstructionsTransactionData,
@@ -11,34 +15,21 @@ export type {
   PaymentItemizedItem,
   SessionDataPayload,
 } from "./transaction_data.ts";
-
 export { TX_DATA_TYPE, transactionData } from "./transaction_data.ts";
 
 export type {
-  DCQLQuery,
-  DCQLCredentialQuery,
-  DCQLCredentialQueryMeta,
-} from "./dcql.ts";
-
-export { DCQL_QUERY_BASIC } from "./dcql.ts";
-
-export { ProofCredentialV1 } from "./proof_credentials.ts";
-
-export type {
-  AuthorizationRequestParams,
+  ServerClientConfig,
+  ServerAuthorizationRequestParams,
+  ServerVCClient,
   DCAPIAuthorizationRequestParams,
   AuthorizationRequest,
-} from "./presentation/base_client.ts";
+} from "./client.ts";
+export { createClient } from "./client.ts";
+
 export type {
-  NodeInitParams,
+  VerifierConfig,
   VerifyParams,
   VerifyVPTokenParams,
-} from "./presentation/node_client.ts";
-
-export {
-  init,
-  getAuthorizationRequestURL,
-  getDCAPIAuthorizationRequest,
-  verify,
-  verifyVPToken,
-} from "./vc_presentation.node.ts";
+  Verifier,
+} from "./verifier.ts";
+export { createVerifier } from "./verifier.ts";
diff --git a/src/proof_credential_factory.ts b/packages/server/src/proof_credential_factory.ts
similarity index 90%
rename from src/proof_credential_factory.ts
rename to packages/server/src/proof_credential_factory.ts
index 15a0754..b400f3e 100644
--- a/src/proof_credential_factory.ts
+++ b/packages/server/src/proof_credential_factory.ts
@@ -4,7 +4,7 @@ import {
   ProofCredentialV1,
 } from "./proof_credentials.ts";
 import { hasher } from "@owf/crypto";
-import { PROOF_CREDENTIAL_V1_VCT } from "./constants.ts";
+import { PROOF_CREDENTIAL_V1_VCT } from "@proof.com/proof-vc-common";
 
 export const getProofCredential = async (
   sdjwt: SDJwt,
@@ -41,6 +41,6 @@ export const getProofCredential = async (
       }),
     });
   } else {
-    throw `unknown ProofCredential for vct: ${vct}`;
+    throw new Error(`unknown ProofCredential for vct: ${vct}`);
   }
 };
diff --git a/src/proof_credentials.ts b/packages/server/src/proof_credentials.ts
similarity index 93%
rename from src/proof_credentials.ts
rename to packages/server/src/proof_credentials.ts
index 329fcfd..8ac8a9f 100644
--- a/src/proof_credentials.ts
+++ b/packages/server/src/proof_credentials.ts
@@ -1,4 +1,5 @@
-import type { CredentialType, Format, ProofCredential } from "./types.ts";
+import type { CredentialType, Format } from "@proof.com/proof-vc-common";
+import type { ProofCredential } from "./types.ts";
 import type { SDJwt } from "@sd-jwt/core";
 
 export type { ProofCredential } from "./types.ts";
diff --git a/src/transaction_data.ts b/packages/server/src/transaction_data.ts
similarity index 98%
rename from src/transaction_data.ts
rename to packages/server/src/transaction_data.ts
index 40e18f6..1bbaeea 100644
--- a/src/transaction_data.ts
+++ b/packages/server/src/transaction_data.ts
@@ -1,4 +1,4 @@
-import { DEFAULT_CREDENTIAL_ID } from "./constants.ts";
+import { DEFAULT_CREDENTIAL_ID } from "@proof.com/proof-vc-common";
 
 export const TX_DATA_TYPE = {
   WIRE_INSTRUCTIONS:
diff --git a/packages/server/src/types.ts b/packages/server/src/types.ts
new file mode 100644
index 0000000..7949669
--- /dev/null
+++ b/packages/server/src/types.ts
@@ -0,0 +1,18 @@
+import type { SDJwt } from "@sd-jwt/core";
+import type {
+  CredentialID,
+  CredentialType,
+  Format,
+} from "@proof.com/proof-vc-common";
+
+export type TrustRoot = "development" | "production";
+
+export interface ProofCredential {
+  credentialType(): CredentialType;
+  format(): Format;
+  getClaims(): Record<string, unknown>;
+  getSDJWT(): SDJwt;
+  getNonce(): string | undefined;
+}
+
+export type VPToken = Record<CredentialID, ProofCredential[]>;
diff --git a/src/utils.ts b/packages/server/src/utils.ts
similarity index 63%
rename from src/utils.ts
rename to packages/server/src/utils.ts
index b1e7fd8..378ae8f 100644
--- a/src/utils.ts
+++ b/packages/server/src/utils.ts
@@ -1,5 +1,7 @@
-import type { CredentialID } from "./types.ts";
-import { DEFAULT_CREDENTIAL_ID } from "./constants.ts";
+import {
+  type CredentialID,
+  DEFAULT_CREDENTIAL_ID,
+} from "@proof.com/proof-vc-common";
 
 const CREDENTIAL_IDS: CredentialID[] = [DEFAULT_CREDENTIAL_ID];
 
@@ -9,5 +11,5 @@ export const credentialIdAsType = (s: string): CredentialID => {
       return credentialId;
     }
   }
-  throw `invalid CredentialID: ${s}`;
+  throw new Error(`invalid CredentialID: ${s}`);
 };
diff --git a/packages/server/src/verifier.ts b/packages/server/src/verifier.ts
new file mode 100644
index 0000000..54381e9
--- /dev/null
+++ b/packages/server/src/verifier.ts
@@ -0,0 +1,155 @@
+import { X509Certificate } from "node:crypto";
+import { Buffer } from "node:buffer";
+import { SDJwtVcInstance } from "@sd-jwt/sd-jwt-vc";
+import type { JwtPayload } from "@sd-jwt/types";
+import { ES256, ES384, ES512, hasher } from "@owf/crypto";
+import { base64urlDecode } from "@owf/identity-common";
+
+import type { ProofCredential, TrustRoot, VPToken } from "./types.ts";
+import { credentialIdAsType } from "./utils.ts";
+import { getProofCredential } from "./proof_credential_factory.ts";
+import { verifyChain } from "./certificates/chain_validator.ts";
+import { getTrustRoot } from "./certificates/trust_store/index.ts";
+
+export type VerifierConfig = {
+  trustRoot: TrustRoot;
+};
+
+export type VerifyParams = {
+  encodedSDJWT: string;
+  aud?: string;
+};
+
+export type VerifyVPTokenParams = {
+  encodedVPToken: string;
+  aud?: string;
+};
+
+const VERIFIERS = { ES256, ES384, ES512 } as const;
+type SupportedAlg = keyof typeof VERIFIERS;
+
+const EXPECTED_CURVE: Record<SupportedAlg, string> = {
+  ES256: "P-256",
+  ES384: "P-384",
+  ES512: "P-521",
+};
+
+function isSupportedAlg(s: unknown): s is SupportedAlg {
+  return typeof s === "string" && s in VERIFIERS;
+}
+
+function kbVerifierFor(kbAlg: SupportedAlg) {
+  return async (
+    data: string,
+    sig: string,
+    payload: JwtPayload,
+  ): Promise<boolean> => {
+    const cnfJwk = payload.cnf?.jwk;
+    if (cnfJwk === undefined) {
+      throw new Error("SD-JWT-VC is missing cnf.jwk — cannot verify KB JWT");
+    }
+    if (cnfJwk.crv !== EXPECTED_CURVE[kbAlg]) {
+      throw new Error(
+        `cnf.jwk curve ${cnfJwk.crv} does not match KB JWT alg ${kbAlg}`,
+      );
+    }
+    const verifier = await VERIFIERS[kbAlg].getVerifier(cnfJwk);
+    return verifier(data, sig);
+  };
+}
+
+export interface Verifier {
+  verify(params: VerifyParams): Promise<ProofCredential>;
+  verifyVPToken(params: VerifyVPTokenParams): Promise<VPToken>;
+}
+
+export function createVerifier(config: VerifierConfig): Verifier {
+  async function verify({
+    encodedSDJWT,
+    aud,
+  }: VerifyParams): Promise<ProofCredential> {
+    const decoded = await new SDJwtVcInstance({ hasher }).decode(encodedSDJWT);
+    const alg = decoded.jwt?.header?.["alg"];
+    const x5c = decoded.jwt?.header?.["x5c"];
+
+    if (!isSupportedAlg(alg)) {
+      throw new Error(`Unsupported or missing alg: ${alg}`);
+    }
+    if (!Array.isArray(x5c) || x5c.length === 0) {
+      throw new Error("JWT header x5c is missing or empty");
+    }
+
+    let kbVerifier = null;
+    let keyBindingNonce: string | undefined;
+    const kbAlg = decoded.kbJwt?.header?.alg;
+    if (decoded.kbJwt !== undefined) {
+      if (!isSupportedAlg(kbAlg)) {
+        throw new Error(`Unsupported or missing KB JWT alg: ${kbAlg}`);
+      }
+      if (aud !== undefined && decoded.kbJwt.payload?.aud !== aud) {
+        throw new Error(
+          `KB JWT aud ${decoded.kbJwt.payload?.aud} does not match expected aud ${aud}`,
+        );
+      }
+      keyBindingNonce = decoded.kbJwt.payload?.nonce;
+      if (keyBindingNonce === undefined) {
+        throw new Error("SD-JWT-VC contains a KB JWT but no nonce claim");
+      }
+      kbVerifier = kbVerifierFor(kbAlg);
+    } else if (aud !== undefined) {
+      throw new Error(
+        "aud was supplied for verification but the SD-JWT-VC contains no KB JWT",
+      );
+    }
+
+    const chain = x5c.map(
+      (b64) => new X509Certificate(Buffer.from(b64 as string, "base64")),
+    );
+    verifyChain(chain, getTrustRoot(config.trustRoot));
+
+    const leafJwk = chain[0]!.publicKey.export({ format: "jwk" });
+    if (leafJwk.crv !== EXPECTED_CURVE[alg]) {
+      throw new Error(
+        `Leaf cert curve ${leafJwk.crv} does not match alg ${alg}`,
+      );
+    }
+
+    const verifier = await VERIFIERS[alg].getVerifier(leafJwk);
+    const SDJWTClient = new SDJwtVcInstance({
+      hasher,
+      verifier,
+      ...(kbVerifier !== null && { kbVerifier }),
+    });
+    await SDJWTClient.verify(encodedSDJWT, {
+      ...(keyBindingNonce !== undefined && { keyBindingNonce }),
+    });
+
+    return getProofCredential(decoded);
+  }
+
+  async function verifyVPToken({
+    encodedVPToken,
+    aud,
+  }: VerifyVPTokenParams): Promise<VPToken> {
+    const records = JSON.parse(base64urlDecode(encodedVPToken)) as Record<
+      string,
+      string[]
+    >;
+    const vpToken = {} as VPToken;
+
+    for (const [key, encodedSDJWTs] of Object.entries(records)) {
+      const credentialId = credentialIdAsType(key);
+      vpToken[credentialId] = [];
+      for (const encodedSDJWT of encodedSDJWTs) {
+        const credential = await verify({
+          encodedSDJWT,
+          ...(aud !== undefined && { aud }),
+        });
+        vpToken[credentialId].push(credential);
+      }
+    }
+    return vpToken;
+  }
+
+  return { verify, verifyVPToken };
+}
diff --git a/test/fixtures/example-identity-vc.txt b/packages/server/test/fixtures/example-identity-vc.txt
similarity index 100%
rename from test/fixtures/example-identity-vc.txt
rename to packages/server/test/fixtures/example-identity-vc.txt
diff --git a/test/verify.test.mjs b/packages/server/test/verify.test.mjs
similarity index 82%
rename from test/verify.test.mjs
rename to packages/server/test/verify.test.mjs
index 75dbf3b..9e57955 100644
--- a/test/verify.test.mjs
+++ b/packages/server/test/verify.test.mjs
@@ -2,7 +2,7 @@ import { test } from "node:test";
 import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 
-import { init, verify } from "../dist/index.node.js";
+import { createVerifier } from "../dist/index.js";
 
 const VC = readFileSync(
   new URL("./fixtures/example-identity-vc.txt", import.meta.url),
@@ -67,60 +67,57 @@ function tamperSignature(vc, segmentIndex) {
   return segments.join("~");
 }
 
+const development = createVerifier({ trustRoot: "development" });
+const production = createVerifier({ trustRoot: "production" });
+
 test("a valid VC passes issuer signature, KB signature, sd_hash, chain, and aud", async () => {
-  init({ trustRoot: "development" });
   await rejectsContaining(
-    () => verify({ encodedSDJWT: VC, aud: AUD }),
+    () => development.verify({ encodedSDJWT: VC, aud: AUD }),
     `unknown ProofCredential for vct: ${VCT}`,
   );
 });
 
 test("aud is optional and skipped when omitted", async () => {
-  init({ trustRoot: "development" });
   await rejectsContaining(
-    () => verify({ encodedSDJWT: VC }),
+    () => development.verify({ encodedSDJWT: VC }),
     `unknown ProofCredential for vct: ${VCT}`,
   );
 });
 
 test("rejects a mismatched aud", async () => {
-  init({ trustRoot: "development" });
   await rejectsContaining(
-    () => verify({ encodedSDJWT: VC, aud: "https://evil.example.com" }),
+    () =>
+      development.verify({ encodedSDJWT: VC, aud: "https://evil.example.com" }),
     "does not match expected aud",
   );
 });
 
 test("rejects a tampered issuer signature", async () => {
-  init({ trustRoot: "development" });
   await rejectsContaining(
-    () => verify({ encodedSDJWT: tamperSignature(VC, 0) }),
+    () => development.verify({ encodedSDJWT: tamperSignature(VC, 0) }),
     "Invalid JWT Signature",
   );
 });
 
 test("rejects a tampered key-binding signature", async () => {
-  init({ trustRoot: "development" });
   await rejectsContaining(
-    () => verify({ encodedSDJWT: tamperSignature(VC, 2) }),
+    () => development.verify({ encodedSDJWT: tamperSignature(VC, 2) }),
     "Invalid JWT Signature",
   );
 });
 
 test("rejects an altered presentation (sd_hash mismatch)", async () => {
-  init({ trustRoot: "development" });
   const segments = VC.split("~");
   const withoutDisclosure = [segments[0], segments[2]].join("~");
   await rejectsContaining(
-    () => verify({ encodedSDJWT: withoutDisclosure, aud: AUD }),
+    () => development.verify({ encodedSDJWT: withoutDisclosure, aud: AUD }),
     "Invalid sd_hash",
   );
 });
 
 test("rejects a chain that does not match the configured trust root", async () => {
-  init({ trustRoot: "production" });
   await rejectsContaining(
-    () => verify({ encodedSDJWT: VC, aud: AUD }),
+    () => production.verify({ encodedSDJWT: VC, aud: AUD }),
     "not issued by next in chain",
   );
 });
diff --git a/packages/server/tsconfig.json b/packages/server/tsconfig.json
new file mode 100644
index 0000000..1e9eb19
--- /dev/null
+++ b/packages/server/tsconfig.json
@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "lib": ["ESNext"],
+    "types": ["node"]
+  },
+  "include": ["src"],
+  "references": [{ "path": "../common" }]
+}
diff --git a/src/index.browser.ts b/src/index.browser.ts
deleted file mode 100644
index 1d03b2f..0000000
--- a/src/index.browser.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-export type * from "./types.ts";
-export type {
-  TransactionData,
-  WireInstructionsTransactionData,
-  PaymentMandateTransactionData,
-  PaymentItemizedTransactionData,
-  SessionDataTransactionData,
-  WireInstructionsPayload,
-  PaymentMandatePayload,
-  PaymentItemizedPayload,
-  PaymentItemizedItem,
-  SessionDataPayload,
-} from "./transaction_data.ts";
-
-export { TX_DATA_TYPE, transactionData } from "./transaction_data.ts";
-
-export type {
-  DCQLQuery,
-  DCQLCredentialQuery,
-  DCQLCredentialQueryMeta,
-} from "./dcql.ts";
-
-export { DCQL_QUERY_BASIC } from "./dcql.ts";
-
-export type {
-  BrowserInitParams,
-  AuthorizationRequestParams,
-  DCAPIAuthorizationRequestParams,
-  AuthorizationRequest,
-} from "./presentation/base_client.ts";
-
-export {
-  init,
-  getAuthorizationRequestURL,
-  getDCAPIAuthorizationRequest,
-} from "./vc_presentation.browser.ts";
diff --git a/src/presentation/base_client.ts b/src/presentation/base_client.ts
deleted file mode 100644
index e419c50..0000000
--- a/src/presentation/base_client.ts
+++ /dev/null
@@ -1,180 +0,0 @@
-import type {
-  Environment,
-  ResponseMode,
-  ResponseType,
-  Scope,
-} from "../types.ts";
-import {
-  encodeTransactionData,
-  type TransactionData,
-} from "../transaction_data.ts";
-import type { DCQLQuery } from "../dcql.ts";
-
-export type BrowserInitParams = {
-  environment: Environment;
-  clientId: string;
-  callbackUri: string;
-  responseMode?: ResponseMode;
-};
-
-type BaseAuthorizationRequestParams = {
-  nonce: string;
-  state?: string;
-  loginHint?: string;
-  transactionData?: TransactionData | string;
-};
-
-export type AuthorizationRequestParams = BaseAuthorizationRequestParams &
-  (
-    | { scope: Scope; dcqlQuery?: never }
-    | { dcqlQuery: DCQLQuery; scope?: never }
-  );
-
-export type DCAPIAuthorizationRequestParams = {
-  dcqlQuery: DCQLQuery;
-  nonce: string;
-  transactionData?: TransactionData | string;
-};
-
-export type AuthorizationRequest = {
-  response_type: ResponseType;
-  response_mode: "dc_api";
-  nonce: string;
-  dcql_query: DCQLQuery;
-  transaction_data?: string[];
-};
-
-export class VCPresentationClient {
-  protected readonly environment?: Environment;
-  protected readonly clientId?: string;
-  protected readonly responseMode: ResponseMode = "fragment";
-  protected readonly responseType: ResponseType = "vp_token";
-  protected readonly callbackUri?: string;
-  protected readonly oid4vpUri = "/verifiable-credentials/v1/presentation";
-
-  constructor(params: {
-    environment?: Environment;
-    clientId?: string;
-    responseMode?: ResponseMode;
-    callbackUri?: string;
-  }) {
-    if (params.environment !== undefined) {
-      this.environment = params.environment;
-    }
-    if (params.clientId !== undefined) {
-      this.clientId = params.clientId;
-    }
-    if (params.callbackUri !== undefined) {
-      this.callbackUri = params.callbackUri;
-    }
-    if (params.responseMode !== undefined) {
-      this.responseMode = params.responseMode;
-    }
-  }
-
-  public async getAuthorizationRequestURL(
-    params: AuthorizationRequestParams,
-  ): Promise<string> {
-    this.requireRequestConfig();
-    return this.buildAuthorizeURL(params);
-  }
-
-  // Builds an unsigned DC API request (`response_mode: "dc_api"`). DC API
-  // requests will eventually be signed (`response_mode: "dc_api.jwt"`).
-  public getDCAPIAuthorizationRequest({
-    dcqlQuery,
-    nonce,
-    transactionData,
-  }: DCAPIAuthorizationRequestParams): AuthorizationRequest {
-    const encodedTransactionData =
-      typeof transactionData === "object"
-        ? encodeTransactionData(transactionData)
-        : transactionData;
-    return {
-      response_type: this.responseType,
-      response_mode: "dc_api",
-      nonce,
-      dcql_query: dcqlQuery,
-      ...(encodedTransactionData !== undefined && {
-        transaction_data: [encodedTransactionData],
-      }),
-    };
-  }
-
-  protected requireRequestConfig(): void {
-    if (this.environment === undefined) {
-      throw "getAuthorizationRequestURL requires `environment` in init()";
-    }
-    if (this.clientId === undefined) {
-      throw "getAuthorizationRequestURL requires `clientId` in init()";
-    }
-    if (this.callbackUri === undefined) {
-      throw "getAuthorizationRequestURL requires `callbackUri` in init()";
-    }
-  }
-
-  protected baseURL(): string {
-    switch (this.environment) {
-      case "localhost":
-        return "https://api.local.dev-notarize.com";
-      case "next":
-        return "https://api.next.proof.com";
-      case "staging":
-        return "https://api.staging.proof.com";
-      case "sandbox":
-        return "https://api.fairfax.proof.com";
-      case "production":
-        return "https://api.proof.com";
-      default:
-        throw "getAuthorizationRequestURL requires `environment` in init()";
-    }
-  }
-
-  protected buildAuthorizeURL(params: AuthorizationRequestParams): string {
-    const url = new URL(`${this.oid4vpUri}/authorize`, this.baseURL());
-    url.search = this.buildParameters(params).toString();
-    return url.toString();
-  }
-
-  protected buildParameters({
-    scope,
-    dcqlQuery,
-    nonce,
-    state,
-    loginHint,
-    transactionData,
-  }: AuthorizationRequestParams): URLSearchParams {
-    if ((scope === undefined) === (dcqlQuery === undefined)) {
-      throw "authorization request requires exactly one of `scope` or `dcqlQuery`";
-    }
-    const encodedTransactionData =
-      typeof transactionData === "object"
-        ? encodeTransactionData(transactionData)
-        : transactionData;
-    return new URLSearchParams({
-      ...this.defaultAuthorizationRequestParameters(),
-      ...(scope !== undefined && { scope }),
-      ...(dcqlQuery !== undefined && { dcql_query: JSON.stringify(dcqlQuery) }),
-      nonce,
-      ...(state !== undefined && { state }),
-      ...(loginHint !== undefined && { login_hint: loginHint }),
-      ...(encodedTransactionData !== undefined && {
-        transaction_data: encodedTransactionData,
-      }),
-    });
-  }
-
-  protected defaultAuthorizationRequestParameters(): Record<string, string> {
-    return {
-      client_id: this.clientId!,
-      response_mode: this.responseMode,
-      response_type: this.responseType,
-      ...(this.responseMode === "fragment" && {
-        redirect_uri: this.callbackUri!,
-      }),
-      ...(this.responseMode === "direct_post" && {
-        response_uri: this.callbackUri!,
-      }),
-    };
-  }
-}
diff --git a/src/presentation/node_client.ts b/src/presentation/node_client.ts
deleted file mode 100644
index d4ea6a8..0000000
--- a/src/presentation/node_client.ts
+++ /dev/null
@@ -1,228 +0,0 @@
-import { X509Certificate } from "node:crypto";
-import { Buffer } from "node:buffer";
-import { SDJwtVcInstance } from "@sd-jwt/sd-jwt-vc";
-import type { JwtPayload } from "@sd-jwt/types";
-import { ES256, ES384, ES512, hasher } from "@owf/crypto";
-import { base64urlDecode } from "@owf/identity-common";
-
-import type {
-  Environment,
-  ProofCredential,
-  ResponseMode,
-  TrustRoot,
-  VPToken,
-} from "../types.ts";
-import { credentialIdAsType } from "../utils.ts";
-import { getProofCredential } from "../proof_credential_factory.ts";
-import { verifyChain } from "../certificates/chain_validator.ts";
-import { getTrustRoot } from "../certificates/trust_store/index.ts";
-import {
-  VCPresentationClient,
-  type AuthorizationRequestParams,
-} from "./base_client.ts";
-
-export type NodeInitParams = {
-  trustRoot?: TrustRoot;
-  environment?: Environment;
-  clientId?: string;
-  clientSecret?: string;
-  callbackUri?: string;
-  responseMode?: ResponseMode;
-  usePushedAuthorizationRequest?: boolean;
-};
-
-export type VerifyParams = {
-  encodedSDJWT: string;
-  aud?: string;
-};
-
-export type VerifyVPTokenParams = {
-  encodedVPToken: string;
-  aud?: string;
-};
-
-const VERIFIERS = { ES256, ES384, ES512 } as const;
-type SupportedAlg = keyof typeof VERIFIERS;
-
-const EXPECTED_CURVE: Record<SupportedAlg, string> = {
-  ES256: "P-256",
-  ES384: "P-384",
-  ES512: "P-521",
-};
-
-function isSupportedAlg(s: unknown): s is SupportedAlg {
-  return typeof s === "string" && s in VERIFIERS;
-}
-
-function kbVerifierFor(kbAlg: SupportedAlg) {
-  return async (
-    data: string,
-    sig: string,
-    payload: JwtPayload,
-  ): Promise<boolean> => {
-    const cnfJwk = payload.cnf?.jwk;
-    if (cnfJwk === undefined) {
-      throw "SD-JWT-VC is missing cnf.jwk — cannot verify KB JWT";
-    }
-    if (cnfJwk.crv !== EXPECTED_CURVE[kbAlg]) {
-      throw `cnf.jwk curve ${cnfJwk.crv} does not match KB JWT alg ${kbAlg}`;
-    }
-    const verifier = await VERIFIERS[kbAlg].getVerifier(cnfJwk);
-    return verifier(data, sig);
-  };
-}
-
-export class NodeVCPresentationClient extends VCPresentationClient {
-  protected readonly clientSecret?: string;
-  protected readonly usePushedAuthorizationRequest: boolean = false;
-  protected readonly trustRoot?: TrustRoot;
-
-  constructor(params: NodeInitParams) {
-    super(params);
-    if (params.clientSecret !== undefined) {
-      this.clientSecret = params.clientSecret;
-    }
-    if (params.usePushedAuthorizationRequest !== undefined) {
-      this.usePushedAuthorizationRequest = params.usePushedAuthorizationRequest;
-    }
-    if (params.trustRoot !== undefined) {
-      this.trustRoot = params.trustRoot;
-    }
-  }
-
-  public override async getAuthorizationRequestURL(
-    params: AuthorizationRequestParams,
-  ): Promise<string> {
-    this.requireRequestConfig();
-    return this.usePushedAuthorizationRequest
-      ? this.pushAuthorizationRequest(params)
-      : this.buildAuthorizeURL(params);
-  }
-
-  protected override defaultAuthorizationRequestParameters(): Record<
-    string,
-    string
-  > {
-    return {
-      ...super.defaultAuthorizationRequestParameters(),
-      ...(this.clientSecret !== undefined && {
-        client_secret: this.clientSecret,
-      }),
-    };
-  }
-
-  protected async pushAuthorizationRequest(
-    params: AuthorizationRequestParams,
-  ): Promise<string> {
-    if (this.clientSecret === undefined) {
-      throw "pushed authorization requests require `clientSecret` in init()";
-    }
-    const parURL = new URL(`${this.oid4vpUri}/par`, this.baseURL()).toString();
-    const response = await fetch(parURL, {
-      method: "POST",
-      headers: { "Content-Type": "application/x-www-form-urlencoded" },
-      body: this.buildParameters(params).toString(),
-    });
-    const data = await response.json();
-
-    if (!response.ok) {
-      throw `${data["error"]}: ${data["error_description"]}`;
-    }
-
-    const authorizeURL = new URL(`${this.oid4vpUri}/authorize`, this.baseURL());
-    authorizeURL.search = new URLSearchParams({
-      client_id: this.clientId!,
-      request_uri: data["request_uri"],
-    }).toString();
-
-    return authorizeURL.toString();
-  }
-
-  protected requireTrustRoot(): TrustRoot {
-    if (this.trustRoot === undefined) {
-      throw "verify requires `trustRoot` in init()";
-    }
-    return this.trustRoot;
-  }
-
-  public async verify({
-    encodedSDJWT,
-    aud,
-  }: VerifyParams): Promise<ProofCredential> {
-    const decoded = await new SDJwtVcInstance({ hasher }).decode(encodedSDJWT);
-    const alg = decoded.jwt?.header?.["alg"];
-    const x5c = decoded.jwt?.header?.["x5c"];
-
-    if (!isSupportedAlg(alg)) {
-      throw `Unsupported or missing alg: ${alg}`;
-    }
-    if (!Array.isArray(x5c) || x5c.length === 0) {
-      throw "JWT header x5c is missing or empty";
-    }
-
-    let kbVerifier = null;
-    let keyBindingNonce: string | undefined;
-    const kbAlg = decoded.kbJwt?.header?.alg;
-    if (decoded.kbJwt !== undefined) {
-      if (!isSupportedAlg(kbAlg)) {
-        throw `Unsupported or missing KB JWT alg: ${kbAlg}`;
-      }
-      if (aud !== undefined && decoded.kbJwt.payload?.aud !== aud) {
-        throw `KB JWT aud ${decoded.kbJwt.payload?.aud} does not match expected aud ${aud}`;
-      }
-      keyBindingNonce = decoded.kbJwt.payload?.nonce;
-      if (keyBindingNonce === undefined) {
-        throw "SD-JWT-VC contains a KB JWT but no nonce claim";
-      }
-      kbVerifier = kbVerifierFor(kbAlg);
-    } else if (aud !== undefined) {
-      throw "aud was supplied for verification but the SD-JWT-VC contains no KB JWT";
-    }
-
-    const chain = x5c.map(
-      (b64) => new X509Certificate(Buffer.from(b64 as string, "base64")),
-    );
-    verifyChain(chain, getTrustRoot(this.requireTrustRoot()));
-
-    const leafJwk = chain[0]!.publicKey.export({ format: "jwk" });
-    if (leafJwk.crv !== EXPECTED_CURVE[alg]) {
-      throw `Leaf cert curve ${leafJwk.crv} does not match alg ${alg}`;
-    }
-
-    const verifier = await VERIFIERS[alg].getVerifier(leafJwk);
-    const SDJWTClient = new SDJwtVcInstance({
-      hasher,
-      verifier,
-      ...(kbVerifier !== null && { kbVerifier }),
-    });
-    await SDJWTClient.verify(encodedSDJWT, {
-      ...(keyBindingNonce !== undefined && { keyBindingNonce }),
-    });
-
-    return getProofCredential(decoded);
-  }
-
-  public async verifyVPToken({
-    encodedVPToken,
-    aud,
-  }: VerifyVPTokenParams): Promise<VPToken> {
-    const records = JSON.parse(base64urlDecode(encodedVPToken)) as Record<
-      string,
-      string[]
-    >;
-    const vpToken = {} as VPToken;
-
-    for (const [key, encodedSDJWTs] of Object.entries(records)) {
-      const credentialId = credentialIdAsType(key);
-      vpToken[credentialId] = [];
-      for (const encodedSDJWT of encodedSDJWTs) {
-        const credential = await this.verify({
-          encodedSDJWT,
-          ...(aud !== undefined && { aud }),
-        });
-        vpToken[credentialId].push(credential);
-      }
-    }
-    return vpToken;
-  }
-}
diff --git a/src/vc_presentation.browser.ts b/src/vc_presentation.browser.ts
deleted file mode 100644
index 57fb829..0000000
--- a/src/vc_presentation.browser.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import {
-  VCPresentationClient,
-  type BrowserInitParams,
-  type AuthorizationRequestParams,
-  type DCAPIAuthorizationRequestParams,
-  type AuthorizationRequest,
-} from "./presentation/base_client.ts";
-
-let instance: VCPresentationClient | null = null;
-
-export function init(params: BrowserInitParams): void {
-  if (params.environment === "production" && instance)
-    throw "VCPresentationClient already initialized (browser)";
-  instance = new VCPresentationClient(params);
-}
-
-export async function getAuthorizationRequestURL(
-  params: AuthorizationRequestParams,
-): Promise<string> {
-  if (!instance)
-    throw "VCPresentationClient not initialized — call init() first (browser)";
-  return instance.getAuthorizationRequestURL(params);
-}
-
-export function getDCAPIAuthorizationRequest(
-  params: DCAPIAuthorizationRequestParams,
-): AuthorizationRequest {
-  if (!instance)
-    throw "VCPresentationClient not initialized — call init() first (browser)";
-  return instance.getDCAPIAuthorizationRequest(params);
-}
diff --git a/src/vc_presentation.node.ts b/src/vc_presentation.node.ts
deleted file mode 100644
index 59f9d32..0000000
--- a/src/vc_presentation.node.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import type {
-  AuthorizationRequestParams,
-  DCAPIAuthorizationRequestParams,
-  AuthorizationRequest,
-} from "./presentation/base_client.ts";
-import {
-  NodeVCPresentationClient,
-  type NodeInitParams,
-  type VerifyParams,
-  type VerifyVPTokenParams,
-} from "./presentation/node_client.ts";
-import type { ProofCredential, VPToken } from "./types.ts";
-
-let instance: NodeVCPresentationClient | null = null;
-
-export function init(params: NodeInitParams): void {
-  if (params.environment === "production" && instance)
-    throw "NodeVCPresentationClient already initialized (node)";
-  instance = new NodeVCPresentationClient(params);
-}
-
-export async function getAuthorizationRequestURL(
-  params: AuthorizationRequestParams,
-): Promise<string> {
-  if (!instance)
-    throw "NodeVCPresentationClient not initialized — call init() first (node)";
-  return instance.getAuthorizationRequestURL(params);
-}
-
-export function getDCAPIAuthorizationRequest(
-  params: DCAPIAuthorizationRequestParams,
-): AuthorizationRequest {
-  if (!instance)
-    throw "NodeVCPresentationClient not initialized — call init() first (node)";
-  return instance.getDCAPIAuthorizationRequest(params);
-}
-
-export async function verify(params: VerifyParams): Promise<ProofCredential> {
-  if (!instance)
-    throw "NodeVCPresentationClient not initialized — call init() first (node)";
-  return instance.verify(params);
-}
-
-export async function verifyVPToken(
-  params: VerifyVPTokenParams,
-): Promise<VPToken> {
-  if (!instance)
-    throw "NodeVCPresentationClient not initialized — call init() first (node)";
-  return instance.verifyVPToken(params);
-}
diff --git a/tsconfig.base.json b/tsconfig.base.json
new file mode 100644
index 0000000..d1a128c
--- /dev/null
+++ b/tsconfig.base.json
@@ -0,0 +1,32 @@
+{
+  // Shared compiler options for every workspace package.
+  // Per-package tsconfigs set rootDir/outDir/lib/types and (for the server) references.
+  "compilerOptions": {
+    // Environment
+    "module": "nodenext",
+    "target": "esnext",
+
+    // Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "composite": true,
+
+    // Stricter Typechecking
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "strict": true,
+
+    // Recommended
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+
+    // Custom: allow `.ts` import specifiers, rewritten to `.js` on emit
+    "rewriteRelativeImportExtensions": true,
+    "allowImportingTsExtensions": true
+  }
+}
diff --git a/tsconfig.json b/tsconfig.json
index 4316d89..161e3de 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,48 +1,8 @@
 {
-  // Visit https://aka.ms/tsconfig to read more about this file
-  "compilerOptions": {
-    // File Layout
-    "rootDir": "./src",
-    "outDir": "./dist",
-
-    // Environment Settings
-    // See also https://aka.ms/tsconfig/module
-    "module": "nodenext",
-    "target": "esnext",
-    "types": ["node"],
-    // For nodejs:
-    // "lib": ["esnext"],
-    // "types": ["node"],
-    // and npm install -D @types/node
-
-    // Other Outputs
-    "sourceMap": true,
-    "declaration": true,
-    "declarationMap": true,
-
-    // Stricter Typechecking Options
-    "noUncheckedIndexedAccess": true,
-    "exactOptionalPropertyTypes": true,
-
-    // Style Options
-    // "noImplicitReturns": true,
-    // "noImplicitOverride": true,
-    // "noUnusedLocals": true,
-    // "noUnusedParameters": true,
-    // "noFallthroughCasesInSwitch": true,
-    // "noPropertyAccessFromIndexSignature": true,
-
-    // Recommended Options
-    "strict": true,
-    "jsx": "react-jsx",
-    "verbatimModuleSyntax": true,
-    "isolatedModules": true,
-    "noUncheckedSideEffectImports": true,
-    "moduleDetection": "force",
-    "skipLibCheck": true,
-
-    // custom options
-    "rewriteRelativeImportExtensions": true,
-    "allowImportingTsExtensions": true
-  }
+  // Solution file: `tsc -b` builds every referenced package in dependency order.
+  "files": [],
+  "references": [
+    { "path": "./packages/common" },
+    { "path": "./packages/server" }
+  ]
 }
diff --git a/yarn.lock b/yarn.lock
index 5ec4038..3d0c38d 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -134,29 +134,35 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@proof.com/proof-vc-common@workspace:.":
+"@proof.com/proof-vc-common@npm:^0.3.0, @proof.com/proof-vc-common@workspace:packages/common":
   version: 0.0.0-use.local
-  resolution: "@proof.com/proof-vc-common@workspace:."
+  resolution: "@proof.com/proof-vc-common@workspace:packages/common"
+  dependencies:
+    publint: "npm:^0.3.21"
+    typescript: "npm:^6.0.3"
+  languageName: unknown
+  linkType: soft
+
+"@proof.com/proof-vc-server@workspace:packages/server":
+  version: 0.0.0-use.local
+  resolution: "@proof.com/proof-vc-server@workspace:packages/server"
   dependencies:
     "@owf/crypto": "npm:^0.3.0"
     "@owf/identity-common": "npm:^0.3.0"
+    "@proof.com/proof-vc-common": "npm:^0.3.0"
     "@sd-jwt/core": "npm:^0.19.0"
     "@sd-jwt/sd-jwt-vc": "npm:^0.19.0"
-    "@types/node": "npm:^24.13.2"
-    eslint: "npm:^10.5.0"
-    eslint-plugin-unused-imports: "npm:^4.4.1"
-    prettier: "npm:^3.8.4"
-    prettier-plugin-packagejson: "npm:^3.0.2"
     publint: "npm:^0.3.21"
     typescript: "npm:^6.0.3"
-    typescript-eslint: "npm:^8.62.0"
   languageName: unknown
   linkType: soft
 
 "@publint/pack@npm:^0.1.4":
-  version: 0.1.4
-  resolution: "@publint/pack@npm:0.1.4"
-  checksum: 10c0/f70b2c8951b5d312ecfd40534e1dd1b0a4fe0fd207879a73c168e3f6979df6202b8b4d4f9a0ee9de6443f0bfb95ef47a0c27c7138c083d9224ef27c67adddefd
+  version: 0.1.5
+  resolution: "@publint/pack@npm:0.1.5"
+  dependencies:
+    tinyexec: "npm:^1.2.4"
+  checksum: 10c0/b92344164e5e0c9b7103a8451bf8b0dede475c04ce6150d8d0c2b5a37260068ad35e3869fdc283f6fbaf7e9f19644e2d3728c13e05a35e200f08dce6981fbd97
   languageName: node
   linkType: hard
 
@@ -408,11 +414,11 @@ __metadata:
   linkType: hard
 
 "acorn@npm:^8.16.0":
-  version: 8.16.0
-  resolution: "acorn@npm:8.16.0"
+  version: 8.17.0
+  resolution: "acorn@npm:8.17.0"
   bin:
     acorn: bin/acorn
-  checksum: 10c0/c9c52697227661b68d0debaf972222d4f622aa06b185824164e153438afa7b08273432ca43ea792cadb24dada1d46f6f6bb1ef8de9956979288cc1b96bf9914e
+  checksum: 10c0/5dcefea5f8f023b6cc24cbe71fb5a8112b601d36c4fa07d14e4e6ffc2ee47383332c46b36c766d9437725aa6660156eae50efa0c838719823b50d7c327c4ed42
   languageName: node
   linkType: hard
 
@@ -884,9 +890,9 @@ __metadata:
   linkType: hard
 
 "pako@npm:^2.1.0":
-  version: 2.1.0
-  resolution: "pako@npm:2.1.0"
-  checksum: 10c0/8e8646581410654b50eb22a5dfd71159cae98145bd5086c9a7a816ec0370b5f72b4648d08674624b3870a521e6a3daffd6c2f7bc00fdefc7063c9d8232ff5116
+  version: 2.2.0
+  resolution: "pako@npm:2.2.0"
+  checksum: 10c0/e5d31de1940fdd13cc4014296b0026112483d0834bce4856ca29c8af8438d030c6416986a0f6df7d5372cae18d6dd6c57f48b24a49d6c207c0a4cc66af15c07d
   languageName: node
   linkType: hard
 
@@ -948,6 +954,21 @@ __metadata:
   languageName: node
   linkType: hard
 
+"proof-vc-workspace@workspace:.":
+  version: 0.0.0-use.local
+  resolution: "proof-vc-workspace@workspace:."
+  dependencies:
+    "@types/node": "npm:^24.13.2"
+    eslint: "npm:^10.5.0"
+    eslint-plugin-unused-imports: "npm:^4.4.1"
+    prettier: "npm:^3.8.4"
+    prettier-plugin-packagejson: "npm:^3.0.2"
+    publint: "npm:^0.3.21"
+    typescript: "npm:^6.0.3"
+    typescript-eslint: "npm:^8.62.0"
+  languageName: unknown
+  linkType: soft
+
 "publint@npm:^0.3.21":
   version: 0.3.21
   resolution: "publint@npm:0.3.21"
@@ -979,11 +1000,11 @@ __metadata:
   linkType: hard
 
 "semver@npm:^7.7.3":
-  version: 7.8.1
-  resolution: "semver@npm:7.8.1"
+  version: 7.8.5
+  resolution: "semver@npm:7.8.5"
   bin:
     semver: bin/semver.js
-  checksum: 10c0/92d6871d6347e1f99d0ba396a70f2545ccf2a032cda3d378fa0699edf7506b5c6d266aed55c8b88e72bd91a30d2351e4f39db479375374430fcdc4b58f4e3c1a
+  checksum: 10c0/b1f3127a5be8125a94f37188b361c212466c292c6910adce3ec106cff5dc211ccaedc4739c11bb70fda59d6fc1f040a9bca289f4e093451521a2372e5231fe0c
   languageName: node
   linkType: hard
 
@@ -1011,8 +1032,8 @@ __metadata:
   linkType: hard
 
 "sort-package-json@npm:^3.6.0":
-  version: 3.6.1
-  resolution: "sort-package-json@npm:3.6.1"
+  version: 3.7.1
+  resolution: "sort-package-json@npm:3.7.1"
   dependencies:
     detect-indent: "npm:^7.0.2"
     detect-newline: "npm:^4.0.1"
@@ -1023,17 +1044,24 @@ __metadata:
     tinyglobby: "npm:^0.2.15"
   bin:
     sort-package-json: cli.js
-  checksum: 10c0/169ea6b8fa233b77ff93f928c73392cbd53573b1faec24692b7b5afdd3487f1b1c3f390467628385dd64e3e01632b7be0c6b380fbb471c70d00c4c7884f44916
+  checksum: 10c0/2403faf859439c10a0562b02c34ff28480171fa8f3991bac6fe8652c8996cfe04f97409e220185f64eefb4c05a5fd83ba43a92d1c8d52a4cdb635bc81113faba
+  languageName: node
+  linkType: hard
+
+"tinyexec@npm:^1.2.4":
+  version: 1.2.4
+  resolution: "tinyexec@npm:1.2.4"
+  checksum: 10c0/153b8db6b080194b558ff145b9cffc36b80a6e07babd644dcfbe49c807eee668c876049d28bdee90b96304476f883352f2dad91b3f86bc23832532f4363e66ff
   languageName: node
   linkType: hard
 
 "tinyglobby@npm:^0.2.15":
-  version: 0.2.16
-  resolution: "tinyglobby@npm:0.2.16"
+  version: 0.2.17
+  resolution: "tinyglobby@npm:0.2.17"
   dependencies:
     fdir: "npm:^6.5.0"
     picomatch: "npm:^4.0.4"
-  checksum: 10c0/f2e09fd93dd95c41e522113b686ff6f7c13020962f8698a864a257f3d7737599afc47722b7ab726e12f8a813f779906187911ff8ee6701ede65072671a7e934b
+  checksum: 10c0/7f7bb0f197c88bc4b20c231e0deca4240ca3bf313a88f5a7fee93a872b84966a4d50220947c0455ad07a60b3b360961c5b7fd979222aeb716a9f99b412002e4c
   languageName: node
   linkType: hard