@forestrie/mcp-register 0.0.0-stage → 0.1.1

package/src/core/issue.ts

@@ -0,0 +1,209 @@
+/**
+ * Issue a child grant as the requester, and complete it once canopy has
+ * sealed it.
+ *
+ * The requester owns an authority log (ARC-0028: the requester funds, the
+ * performer writes) and is its own grant issuer: it signs a child grant
+ * with its authority key, naming the performer's log key in `grantData`.
+ * Forestrie runs no issuer.
+ *
+ * The bytes are the ES256 profile of `@forestrie/grant-builder`'s
+ * `signGrantPayloadWithEs256Pem`, which univocity verifies
+ * (`verifyCoseSign1ES256`), with the PEM replaced by the signer seam:
+ *
+ *  - untagged COSE Sign1, protected `{1: -7}` (wire `a10126`);
+ *  - payload the 32-byte SHA-256 of the canonical grant v0 CBOR;
+ *  - signature over `["Signature1", protected, h'', payload]`, r‖s;
+ *  - unprotected `{-65537: 8 zero bytes, -65538: grant v0 CBOR}`, in that
+ *    canonical order.
+ *
+ * grant-builder itself is not imported: its index pulls in its node-only
+ * PEM module, and this file is browser-safe.
+ *
+ * Completing a grant merges the receipt (396) and the entry's idtimestamp
+ * (-65537) into the unprotected header without re-signing, as forestrie-cli
+ * `register-grant-complete.ts` does. The completed grant is the
+ * `Forestrie-Grant` credential register_statement and delegate_sealing take.
+ */
+import {
+  appendCborBstr,
+  appendCborText,
+  decodeCoseSign1,
+  encodeCborDeterministic,
+  encodeGrantPayloadV0Canonical,
+  mergeUnprotectedIntoCoseSign1,
+  uuidToBytes,
+} from "@forestrie/encoding";
+import { GrantError, type GrantView } from "./grant.js";
+import { bytesEqual, sha256 } from "./hex.js";
+import type { Es256Signer } from "./signer.js";
+
+const ES256_PROTECTED_HEADER = new Uint8Array([0xa1, 0x01, 0x26]);
+// CBOR negative-int keys (major type 1): -65537, then -65538.
+const CBOR_KEY_IDTIMESTAMP = [0x3a, 0x00, 0x01, 0x00, 0x00];
+const CBOR_KEY_FORESTRIE_GRANT_V0 = [0x3a, 0x00, 0x01, 0x00, 0x01];
+const HEADER_RECEIPT = 396;
+const HEADER_IDTIMESTAMP = -65537;
+
+/** canopy's register-grant body key for the parent grant evidence. */
+const PARENT_GRANT_BODY_KEY = "parentGrant";
+/** canopy reads at most this much register-grant body (`auth-grant.ts`). */
+export const MAX_PARENT_GRANT_BYTES = 16 * 1024;
+
+/** GF_CREATE|GF_EXTEND (byte 3), GF_DATA_LOG (byte 7): a data-log creation
+ *  grant, the shape that both opens the child log and carries statements. */
+export function dataLogCreateExtendFlags(): Uint8Array {
+  const flags = new Uint8Array(8);
+  flags[3] = 0x03;
+  flags[7] = 0x02;
+  return flags;
+}
+
+export interface IssueGrantInput {
+  /** The child data log the grant creates (UUID). */
+  logId: string;
+  /** The requester's authority log the grant is sequenced into (UUID). */
+  ownerLogId: string;
+  /** The key the grant names: 64 bytes x‖y of the performer's log key. */
+  grantData: Uint8Array;
+  /** The batch ceiling canopy prices a paid child grant by. At least 1. */
+  maxHeight: number;
+}
+
+export interface IssuedGrant {
+  /** The signed grant, untagged COSE Sign1. */
+  grant: Uint8Array;
+  /** The canonical grant v0 CBOR that was signed (its SHA-256 is the payload). */
+  grantPayload: Uint8Array;
+  flags: Uint8Array;
+}
+
+export async function issueChildGrant(
+  input: IssueGrantInput,
+  authority: Es256Signer,
+): Promise<IssuedGrant> {
+  let logId: Uint8Array;
+  let ownerLogId: Uint8Array;
+  try {
+    logId = uuidToBytes(input.logId);
+    ownerLogId = uuidToBytes(input.ownerLogId);
+  } catch {
+    throw new GrantError(
+      `logId and ownerLogId must be UUIDs (got ${input.logId}, ${input.ownerLogId})`,
+    );
+  }
+  if (bytesEqual(logId, ownerLogId))
+    throw new GrantError(
+      "a child grant must name a log other than its owner (logId equals ownerLogId)",
+    );
+  if (input.grantData.length !== 64)
+    throw new GrantError(
+      `grantData must be a 64-byte ES256 x‖y (got ${input.grantData.length} bytes): canopy forwards only ES256 child roots`,
+    );
+  if (!Number.isSafeInteger(input.maxHeight) || input.maxHeight < 1)
+    throw new GrantError(
+      `maxHeight must be a positive integer (got ${input.maxHeight})`,
+    );
+
+  const flags = dataLogCreateExtendFlags();
+  const grantPayload = encodeGrantPayloadV0Canonical({
+    logId,
+    ownerLogId,
+    grant: flags,
+    maxHeight: input.maxHeight,
+    minGrowth: 0,
+    grantData: input.grantData,
+  });
+  const payload = await sha256(grantPayload);
+
+  const sig: number[] = [0x84];
+  appendCborText(sig, "Signature1");
+  appendCborBstr(sig, ES256_PROTECTED_HEADER);
+  appendCborBstr(sig, new Uint8Array(0));
+  appendCborBstr(sig, payload);
+  const signature = await authority.sign(new Uint8Array(sig));
+  if (signature.length !== 64)
+    throw new GrantError(
+      `the authority signer returned ${signature.length} bytes; ES256 needs a 64-byte r‖s`,
+    );
+
+  const out: number[] = [0x84];
+  appendCborBstr(out, ES256_PROTECTED_HEADER);
+  out.push(0xa2);
+  out.push(...CBOR_KEY_IDTIMESTAMP);
+  appendCborBstr(out, new Uint8Array(8));
+  out.push(...CBOR_KEY_FORESTRIE_GRANT_V0);
+  appendCborBstr(out, grantPayload);
+  appendCborBstr(out, payload);
+  appendCborBstr(out, signature);
+  return { grant: new Uint8Array(out), grantPayload, flags };
+}
+
+/**
+ * Why `parent` cannot authorise a child grant signed by `authorityXY`, or
+ * `[]`. The parent is the requester's own authority grant: an auth-log
+ * grant naming the authority key, whose log becomes the child's owner.
+ */
+export function parentGrantProblems(
+  parent: GrantView,
+  authorityXY: Uint8Array,
+): string[] {
+  const problems: string[] = [];
+  if (!parent.authLog)
+    problems.push(
+      `the parent grant's flags ${parent.flagsHex} are not an authority-log grant (GF_AUTH_LOG); only an authority log can own a child log`,
+    );
+  if (parent.grantData.length !== 64)
+    problems.push(
+      `the parent grant names a ${parent.grantData.length}-byte key; canopy's prepare refuses non-ES256 parents, so the authority key must be ES256`,
+    );
+  else if (!bytesEqual(parent.grantData, authorityXY))
+    problems.push(
+      "the parent grant names a different key than this server's authority key, so this key does not own that authority log and cannot issue under it",
+    );
+  return problems;
+}
+
+/** The register-grant request body: canonical CBOR `{parentGrant: <bytes>}`. */
+export function registerGrantBody(parentGrant: Uint8Array): Uint8Array {
+  return encodeCborDeterministic(
+    new Map<string, unknown>([[PARENT_GRANT_BODY_KEY, parentGrant]]),
+  );
+}
+
+const ENTRY_ID = /^[0-9a-f]{32}$/;
+
+/** Merge the sealed receipt and the entry's idtimestamp into the grant. */
+export function completeGrant(
+  grant: Uint8Array,
+  receipt: Uint8Array,
+  entryIdHex: string,
+): Uint8Array {
+  if (!ENTRY_ID.test(entryIdHex))
+    throw new GrantError(
+      `entryId must be 32 lowercase hex (got ${entryIdHex})`,
+    );
+  const idtimestamp = new Uint8Array(8);
+  for (let i = 0; i < 8; i++)
+    idtimestamp[i] = parseInt(entryIdHex.slice(i * 2, i * 2 + 2), 16);
+  return mergeUnprotectedIntoCoseSign1(
+    grant,
+    new Map<number, unknown>([
+      [HEADER_RECEIPT, receipt],
+      [HEADER_IDTIMESTAMP, idtimestamp],
+    ]),
+  );
+}
+
+/** The grant v0 CBOR a grant carries at unprotected -65538: its content. */
+export function grantContent(grant: Uint8Array): Uint8Array {
+  const sign1 = decodeCoseSign1(grant);
+  const unprotected = sign1?.unprotected;
+  const content =
+    unprotected instanceof Map ? unprotected.get(-65538) : undefined;
+  if (!(content instanceof Uint8Array) || content.length === 0)
+    throw new GrantError(
+      "not a Forestrie-Grant: no grant v0 CBOR at unprotected label -65538",
+    );
+  return content;
+}

package/src/core/limits.ts

@@ -0,0 +1,8 @@
+/**
+ * canopy's statement size limit, `maxStatementSize` in its SCITT
+ * configuration (canopy `scrapi/transparency-configuration.ts`): 4 MiB,
+ * checked against the signed statement's Content-Length. The limit is on
+ * the COSE Sign1 as sent, so the payload must leave room for the headers
+ * and the signature.
+ */
+export const MAX_STATEMENT_BYTES = 4 * 1024 * 1024;

package/src/core/scrapi.ts

@@ -0,0 +1,236 @@
+/**
+ * Read canopy's answers to the write path, over already-fetched responses.
+ *
+ * The registration contract (canopy `scrapi/register-signed-statement.ts`,
+ * `scrapi/query-registration-status.ts`, `scrapi/resolve-receipt.ts`):
+ *
+ *  - `POST /register/{R}/entries` answers 303 with `Location` = the
+ *    transient status URL `…/logs/{R}/{T}/entries/{sha256(statement)}`.
+ *  - The status URL answers 303 to itself (`Retry-After`) until the entry is
+ *    sequenced, then 303 to the permanent receipt URL
+ *    `…/logs/{R}/{T}/{massifHeight}/entries/{entryId}/receipt`.
+ *  - The receipt URL answers 404 "checkpoint missing" (or "checkpoint does
+ *    not cover entry") until a checkpoint covering the entry is sealed,
+ *    then 200 with the receipt. Other 404s are faults.
+ *  - Failures are `application/problem+cbor` maps `{title, status, detail?,
+ *    reason?}`.
+ */
+import { decodeCborDeterministic } from "@forestrie/encoding";
+
+/** The parts of a response these readers look at. Headers keyed lowercase. */
+export interface ResponseView {
+  url: string;
+  status: number;
+  headers: Record<string, string>;
+  body: Uint8Array;
+}
+
+export interface Problem {
+  status: number;
+  title: string;
+  detail?: string;
+  reason?: string;
+  /** From the response's Retry-After, e.g. canopy's queue-full 503. */
+  retryAfterSeconds?: number;
+}
+
+export function readProblem(res: ResponseView): Problem {
+  const retry = retryAfter(res);
+  const base: Problem = {
+    status: res.status,
+    title: `HTTP ${res.status}`,
+    ...(retry !== undefined ? { retryAfterSeconds: retry } : {}),
+  };
+  if (res.body.length === 0) return base;
+  try {
+    const decoded = decodeCborDeterministic(res.body);
+    const get = (k: string): unknown =>
+      decoded instanceof Map
+        ? decoded.get(k)
+        : typeof decoded === "object" && decoded !== null
+          ? (decoded as Record<string, unknown>)[k]
+          : undefined;
+    const title = get("title");
+    const detail = get("detail");
+    const reason = get("reason");
+    if (typeof title === "string")
+      return {
+        ...base,
+        title,
+        ...(typeof detail === "string" ? { detail } : {}),
+        ...(typeof reason === "string" ? { reason } : {}),
+      };
+  } catch {
+    // Not CBOR: fall through to printable text.
+  }
+  const text = new TextDecoder()
+    .decode(res.body)
+    .replace(/[^\x20-\x7e]+/g, " ")
+    .trim();
+  return text ? { ...base, detail: text.slice(0, 200) } : base;
+}
+
+/**
+ * Resolve a Location against the URL that answered, and keep it on the
+ * expected origin: a status or receipt URL that points elsewhere is not
+ * followed (the caller would otherwise fetch wherever a server says).
+ */
+function follow(
+  location: string,
+  res: ResponseView,
+  origin: string | undefined,
+): { ok: true; url: string } | { ok: false; problem: Problem } {
+  let url: URL;
+  try {
+    url = new URL(location, res.url);
+  } catch {
+    return {
+      ok: false,
+      problem: {
+        status: res.status,
+        title: "Invalid Location",
+        detail: `the Location header is not a URL: ${location.slice(0, 200)}`,
+      },
+    };
+  }
+  if (origin !== undefined && url.origin !== origin)
+    return {
+      ok: false,
+      problem: {
+        status: res.status,
+        title: "Unexpected Location",
+        detail: `the Location header points to ${url.origin}, not ${origin}; not following it`,
+      },
+    };
+  return { ok: true, url: url.toString() };
+}
+
+/** The origin of a base URL, or `undefined` when it does not parse. */
+export function originOf(baseUrl: string): string | undefined {
+  try {
+    return new URL(baseUrl).origin;
+  } catch {
+    return undefined;
+  }
+}
+
+export type RegisterOutcome =
+  | { kind: "accepted"; statusUrl: string; retryAfterSeconds?: number }
+  | { kind: "problem"; problem: Problem };
+
+export function readRegisterResponse(
+  res: ResponseView,
+  origin?: string,
+): RegisterOutcome {
+  if (res.status === 303 && res.headers["location"]) {
+    const next = follow(res.headers["location"], res, origin);
+    if (!next.ok) return { kind: "problem", problem: next.problem };
+    const retry = retryAfter(res);
+    return {
+      kind: "accepted",
+      statusUrl: next.url,
+      ...(retry !== undefined ? { retryAfterSeconds: retry } : {}),
+    };
+  }
+  return { kind: "problem", problem: readProblem(res) };
+}
+
+export type RegisterGrantOutcome =
+  | RegisterOutcome
+  | {
+      kind: "payment_required";
+      /** The raw `X-PAYMENT-REQUIRED` header (base64 JSON), undecoded. */
+      paymentRequiredHeader: string;
+      problem: Problem;
+    };
+
+/**
+ * canopy's answer to `POST /register/{R}/grants`: 303 to the grant's status
+ * URL, or 402 with an `X-PAYMENT-REQUIRED` challenge when the parent grant
+ * makes this child payment-gated (and again, with canopy's reason, when a
+ * presented `X-PAYMENT` is refused). A 402 without the header is a problem.
+ */
+export function readRegisterGrantResponse(
+  res: ResponseView,
+  origin?: string,
+): RegisterGrantOutcome {
+  const header = res.headers["x-payment-required"];
+  if (res.status === 402 && header)
+    return {
+      kind: "payment_required",
+      paymentRequiredHeader: header,
+      problem: readProblem(res),
+    };
+  return readRegisterResponse(res, origin);
+}
+
+const RECEIPT_PATH = /\/(\d+)\/entries\/([0-9a-f]{32})\/receipt$/;
+
+export type StatusOutcome =
+  | { kind: "pending"; retryAfterSeconds: number }
+  | {
+      kind: "sequenced";
+      receiptUrl: string;
+      massifHeight: number;
+      entryId: string;
+    }
+  | { kind: "problem"; problem: Problem };
+
+export function readStatusResponse(
+  res: ResponseView,
+  origin?: string,
+): StatusOutcome {
+  if (res.status !== 303)
+    return { kind: "problem", problem: readProblem(res) };
+  const next = follow(res.headers["location"] ?? res.url, res, origin);
+  if (!next.ok) return { kind: "problem", problem: next.problem };
+  const match = RECEIPT_PATH.exec(new URL(next.url).pathname);
+  if (match)
+    return {
+      kind: "sequenced",
+      receiptUrl: next.url,
+      massifHeight: Number(match[1]),
+      entryId: match[2]!,
+    };
+  return { kind: "pending", retryAfterSeconds: retryAfter(res) ?? 1 };
+}
+
+export type ReceiptOutcome =
+  | { kind: "sealed"; receipt: Uint8Array; contentType?: string }
+  | { kind: "awaiting_seal"; reason: string }
+  | { kind: "problem"; problem: Problem };
+
+/**
+ * The 404s that mean "sequenced, not yet sealed": no checkpoint yet, or one
+ * that predates the entry (canopy `scrapi/resolve-receipt.ts`). canopy
+ * answers 404 for other reasons too — a missing massif, a height or index
+ * mismatch, an unknown forest — and those will not fix themselves by
+ * waiting, so they are problems, with canopy's reason.
+ */
+const AWAITING_SEAL =
+  /checkpoint missing\)$|checkpoint does not cover entry\)$/;
+
+export function readReceiptResponse(res: ResponseView): ReceiptOutcome {
+  if (res.status === 404) {
+    const problem = readProblem(res);
+    if (AWAITING_SEAL.test(problem.title))
+      return { kind: "awaiting_seal", reason: problem.title };
+    return { kind: "problem", problem };
+  }
+  if (res.status === 200 && res.body.length > 0)
+    return {
+      kind: "sealed",
+      receipt: res.body,
+      ...(res.headers["content-type"]
+        ? { contentType: res.headers["content-type"] }
+        : {}),
+    };
+  return { kind: "problem", problem: readProblem(res) };
+}
+
+function retryAfter(res: ResponseView): number | undefined {
+  const raw = res.headers["retry-after"];
+  if (raw === undefined) return undefined;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : undefined;
+}

package/src/core/signer.ts

@@ -0,0 +1,23 @@
+/**
+ * The signer seam: every signature this package makes goes through one
+ * `Es256Signer`. Core code builds the exact bytes to be signed and hands
+ * them over; it never sees a private key, and no signature byte ever
+ * arrives from a tool argument. Where the key lives — a local key file
+ * (the default, `src/node/signer-file.ts`), a KMS, a remote signer — is the
+ * backend's business.
+ *
+ * ES256 only: canopy's child-log paths (register-grant auto-forward and
+ * `POST /api/forest/{child}/prepare`) accept 64-byte P-256 roots only, so a
+ * KS256 log key could not delegate its own sealing without an operator.
+ */
+export interface Es256Signer {
+  /** The P-256 public key as 64 bytes x‖y — what a grant's `grantData` names. */
+  publicKeyXY(): Promise<Uint8Array>;
+  /**
+   * ECDSA P-256 with SHA-256 over `message` (the signer hashes), returned as
+   * IEEE P1363 r‖s, 64 bytes. For COSE that message is the Sig_structure.
+   */
+  sign(message: Uint8Array): Promise<Uint8Array>;
+  /** Where the key lives, for humans: never key material. */
+  readonly description: string;
+}

package/src/core/statement.ts

@@ -0,0 +1,133 @@
+/**
+ * Build and sign the statement canopy registers: an untagged COSE Sign1,
+ * payload attached, protected header `{1: -7, 3: cty, 4: kid, 15: {1: iss,
+ * 2: sub}}`, empty unprotected header.
+ *
+ * Byte-for-byte the construction of `@forestrie/encoding`'s
+ * `signCoseSign1Statement` (the one forestrie-cli uses), with the
+ * WebCrypto call replaced by the signer seam: the same protected map, the
+ * same Sig_structure, the same envelope encoder.
+ *
+ * kid is the key's 32-byte x coordinate, the binding canopy checks first
+ * (canopy `grant/statement-signer-binding.ts`).
+ */
+import {
+  COSE_ALG_ES256,
+  encodeCoseProtectedMapBytes,
+  encodeCoseSign1Statement,
+  encodeSigStructure,
+  verifyCoseSign1WithParsedKey,
+  type CoseProtectedHeaderOptions,
+} from "@forestrie/encoding";
+import { MAX_STATEMENT_BYTES } from "./limits.js";
+import { sha256, toHex } from "./hex.js";
+import type { Es256Signer } from "./signer.js";
+
+export class StatementError extends Error {
+  constructor(
+    readonly code: "invalid_input" | "too_large" | "signer_failed",
+    message: string,
+  ) {
+    super(message);
+  }
+}
+
+export interface SignStatementInput {
+  payload: Uint8Array;
+  /** The payload's media type, carried in protected header 3. */
+  contentType: string;
+  /** CWT iss; defaults to the hex of the kid. */
+  issuer?: string;
+  /** CWT sub; defaults to `sha-256:<hex of payload>`, as forestrie-cli does. */
+  subject?: string;
+  /** CWT iat, seconds since the epoch; omitted when absent. */
+  issuedAt?: number;
+}
+
+export interface SignedStatement {
+  statement: Uint8Array;
+  /** sha256 of the statement: the id in canopy's status URL. */
+  contentHash: string;
+  kid: Uint8Array;
+  issuer: string;
+  subject: string;
+}
+
+export async function signStatement(
+  input: SignStatementInput,
+  signer: Es256Signer,
+): Promise<SignedStatement> {
+  if (input.payload.length === 0)
+    throw new StatementError("invalid_input", "payload is empty");
+  if (input.payload.length > MAX_STATEMENT_BYTES)
+    throw new StatementError(
+      "too_large",
+      `payload is ${input.payload.length} bytes; canopy accepts signed statements up to ${MAX_STATEMENT_BYTES} bytes. Register a small manifest naming the artefact's digest instead`,
+    );
+  if (!input.contentType.trim())
+    throw new StatementError("invalid_input", "contentType is empty");
+
+  const xy = await signer.publicKeyXY();
+  if (xy.length !== 64)
+    throw new StatementError(
+      "signer_failed",
+      `signer returned a ${xy.length}-byte public key; ES256 needs 64 bytes x‖y`,
+    );
+  const kid = xy.slice(0, 32);
+  const issuer = input.issuer ?? toHex(kid);
+  const subject =
+    input.subject ?? `sha-256:${toHex(await sha256(input.payload))}`;
+  const options: CoseProtectedHeaderOptions = {
+    alg: COSE_ALG_ES256,
+    cty: input.contentType,
+    cwtClaims: {
+      iss: issuer,
+      sub: subject,
+      ...(input.issuedAt !== undefined ? { iat: input.issuedAt } : {}),
+    },
+  };
+
+  const sigStructure = encodeSigStructure(
+    encodeCoseProtectedMapBytes(kid, options),
+    new Uint8Array(0),
+    input.payload,
+  );
+  const signature = await signer.sign(sigStructure);
+  if (signature.length !== 64)
+    throw new StatementError(
+      "signer_failed",
+      `signer returned a ${signature.length}-byte signature; ES256 is 64 bytes r‖s`,
+    );
+  const statement = encodeCoseSign1Statement(
+    input.payload,
+    kid,
+    signature,
+    options,
+  );
+
+  // Check our own work before canopy does: a signer that signs with a key
+  // other than the one it reports would otherwise surface as a bare 403.
+  const verified = await verifyCoseSign1WithParsedKey(statement, {
+    x: xy.slice(0, 32),
+    y: xy.slice(32),
+    curve: "P-256",
+  });
+  if (!verified)
+    throw new StatementError(
+      "signer_failed",
+      "the signature does not verify under the signer's own public key",
+    );
+  if (statement.length > MAX_STATEMENT_BYTES)
+    throw new StatementError(
+      "too_large",
+      `the signed statement is ${statement.length} bytes; canopy's limit is ${MAX_STATEMENT_BYTES}`,
+    );
+
+  return {
+    statement,
+    contentHash: toHex(await sha256(statement)),
+    kid,
+    issuer,
+    subject,
+  };
+}

package/src/core/version.ts

@@ -0,0 +1,25 @@
+/**
+ * Version strings, as literals.
+ *
+ * Not read from `package.json`: `src/core` is browser-safe, so it has no
+ * `node:fs`, and a JSON import would bake a resolveJsonModule edge into the
+ * `"."` bundle for a handful of strings. The MCP smoke test asserts
+ * `PACKAGE_VERSION === package.json#version`, so a forgotten bump is a red
+ * test rather than a silent lie in `initialize`'s serverInfo.
+ *
+ * Only the versions this package reports (`--help`, `initialize`) live here.
+ * Bump each one in the same commit as the dependency it names.
+ */
+
+/** Keep in sync with package.json#version. Asserted by test/node/mcp-smoke. */
+export const PACKAGE_VERSION = "0.1.1";
+
+/** Keep in sync with package.json#dependencies["@forestrie/mcp-verify"] — the
+ *  verifier this package composes with. Asserted by
+ *  test/core/version.test.ts. */
+export const VERIFIER_VERSION = "0.5.0";
+
+/** Keep in sync with package.json#dependencies["@forestrie/mcp-resolve"] —
+ *  the resolver this package composes with. Asserted by
+ *  test/core/version.test.ts. */
+export const RESOLVE_VERSION = "0.3.0";