@mcpfn/testing 0.0.3 → 0.0.5

package/dist/index.js

@@ -490,7 +490,7 @@ function uniqueScopes(value) {
 function json(status, body) {
   return Response.json(body, {
     status,
-    headers: { "cache-control": "no-store" }
+    headers: { "cache-control": "no-store", pragma: "no-cache" }
   });
 }
 function oauthError(status, error, description) {
@@ -595,8 +595,8 @@ var McpFnMockOAuthAuthorizationServer = class {
   }
   async handle(request) {
     const url = new URL(request.url);
-    const path2 = url.pathname.replace(this.issuer.pathname.replace(/\/$/, ""), "") || "/";
-    if (request.method === "GET" && path2 === "/.well-known/oauth-authorization-server") {
+    const path3 = url.pathname.replace(this.issuer.pathname.replace(/\/$/, ""), "") || "/";
+    if (request.method === "GET" && path3 === "/.well-known/oauth-authorization-server") {
       return json(200, {
         issuer: this.issuer.toString(),
         authorization_endpoint: this.authorizationEndpoint,
@@ -610,20 +610,20 @@ var McpFnMockOAuthAuthorizationServer = class {
         client_id_metadata_document_supported: true
       });
     }
-    if (request.method === "GET" && path2.startsWith("/client-metadata/")) {
+    if (request.method === "GET" && path3.startsWith("/client-metadata/")) {
       const metadata = Object.values(this.clientMetadata).find((candidate) => new URL(candidate.client_id).pathname === url.pathname);
       return metadata ? json(200, metadata) : json(404, { error: "not_found" });
     }
-    if (request.method === "GET" && path2 === "/authorize") {
+    if (request.method === "GET" && path3 === "/authorize") {
       return this.authorize(url);
     }
-    if (request.method === "POST" && path2 === "/token") {
+    if (request.method === "POST" && path3 === "/token") {
       return this.token(await request.text());
     }
-    if (request.method === "POST" && path2 === "/revoke") {
+    if (request.method === "POST" && path3 === "/revoke") {
       return this.revoke(await request.text());
     }
-    if (request.method === "GET" && path2 === "/callback") {
+    if (request.method === "GET" && path3 === "/callback") {
       const parameters = Object.fromEntries(url.searchParams);
       this.callbacks.push({ url: url.toString(), parameters });
       return new Response(
@@ -837,6 +837,34 @@ import {
   customTarget
 } from "@mcpfn/client";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+var testClientCleanupOwners = /* @__PURE__ */ new WeakMap();
+var McpFnTestClientCleanupError = class extends Error {
+  constructor(close, cause) {
+    super(
+      "Test client cleanup remains pending; retain this error and retryCleanup()",
+      { cause }
+    );
+    this.name = "McpFnTestClientCleanupError";
+    testClientCleanupOwners.set(this, { close });
+  }
+  retryCleanup() {
+    const owner = testClientCleanupOwners.get(this);
+    if (!owner) return Promise.resolve();
+    if (owner.pending) return owner.pending;
+    const pending = Promise.resolve().then(owner.close).then(
+      () => {
+        testClientCleanupOwners.delete(this);
+      },
+      () => {
+        throw this;
+      }
+    ).finally(() => {
+      owner.pending = void 0;
+    });
+    owner.pending = pending;
+    return pending;
+  }
+};
 var McpFnTestClient = class _McpFnTestClient {
   session;
   constructor(session) {
@@ -857,8 +885,9 @@ var McpFnTestClient = class _McpFnTestClient {
       }
     }), info, options);
   }
-  static async connectTarget(target, info, options = {}) {
-    const session = createMcpFnClient({
+  /** Create the session owner before connecting, so failed initialization remains closeable. */
+  static createTarget(target, info, options = {}) {
+    return new _McpFnTestClient(createMcpFnClient({
       target,
       info: info ?? { name: "mcpfn-test-client", version: "1.0.0" },
       capabilities: options.capabilities,
@@ -866,12 +895,20 @@ var McpFnTestClient = class _McpFnTestClient {
       events: options.events,
       configure: options.configure,
       diagnostics: options.diagnostics
-    });
+    }));
+  }
+  static async connectTarget(target, info, options = {}) {
+    const client = this.createTarget(target, info, options);
     try {
-      await session.connect();
-      return new _McpFnTestClient(session);
+      await client.session.connect();
+      return client;
     } catch (error) {
-      await session.close(true).catch(() => void 0);
+      const connectionFailure = error instanceof Error && error.cause !== void 0 ? error.cause : error;
+      try {
+        await client.session.close();
+      } catch {
+        throw new McpFnTestClientCleanupError(() => client.session.close(), connectionFailure);
+      }
       throw error;
     }
   }
@@ -920,23 +957,1585 @@ var McpFnTestClient = class _McpFnTestClient {
   complete(params, options) {
     return this.session.prompts.complete(params, options);
   }
-  close() {
-    return this.session.close();
+  async close() {
+    try {
+      await this.session.close();
+    } catch (error) {
+      throw new McpFnTestClientCleanupError(() => this.session.close(), error);
+    }
   }
 };
 
+// src/client-profile-contracts.ts
+import { createHash } from "crypto";
+import Ajv from "ajv";
+import Ajv2019 from "ajv/dist/2019.js";
+import Ajv2020 from "ajv/dist/2020.js";
+import { redactOAuthValue } from "@superfunctions/oauth-core";
+var McpFnClientProfileContractCleanupError = class extends Error {
+  constructor(report, owners) {
+    super("Client profile target cleanup remains pending; retain this error and retryCleanup()");
+    this.report = report;
+    this.owners = owners;
+    this.name = "McpFnClientProfileContractCleanupError";
+  }
+  report;
+  owners;
+  async retryCleanup() {
+    const results = await Promise.allSettled(this.owners.map((owner) => owner.retryCleanup()));
+    if (results.some((result) => result.status === "rejected")) throw this;
+  }
+};
+var ProfileCaseCleanupError = class extends Error {
+  constructor(owner, result) {
+    super("Client profile target cleanup remains pending");
+    this.owner = owner;
+    this.result = result;
+  }
+  owner;
+  result;
+};
+var PORTABILITY_KEYWORDS = /* @__PURE__ */ new Set([
+  "$anchor",
+  "$recursiveAnchor",
+  "$recursiveRef",
+  "$dynamicAnchor",
+  "$dynamicRef",
+  "dependentSchemas",
+  "dependentRequired",
+  "minContains",
+  "maxContains",
+  "prefixItems",
+  "unevaluatedItems",
+  "unevaluatedProperties"
+]);
+function hash(value) {
+  return createHash("sha256").update(stableJson(value)).digest("hex");
+}
+function boundedError(value) {
+  const redacted = String(
+    redactOAuthValue(value instanceof Error ? value.message : value)
+  );
+  return redacted.slice(0, 512);
+}
+function assertProfileReference(id, version) {
+  for (const [label, value] of [
+    ["id", id],
+    ["version", version]
+  ]) {
+    if (typeof value !== "string" || !value || value.length > 128 || !/^[A-Za-z0-9._/-]+$/.test(value)) {
+      throw new Error(
+        `Client profile ${label} must be a non-empty stable identifier`
+      );
+    }
+  }
+}
+function createMcpFnClientProfileSnapshot(profile, tools) {
+  assertProfileReference(profile.id, profile.version);
+  const normalized = [...tools].map((tool) => structuredClone(tool)).sort(
+    (left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0
+  );
+  if (normalized.some((tool, index) => index > 0 && tool.name === normalized[index - 1].name)) {
+    throw new Error("Effective catalog contains duplicate tool names");
+  }
+  return {
+    formatVersion: 1,
+    kind: "mcpfn.client-profile-snapshot",
+    profile: { id: profile.id, version: profile.version },
+    catalogHash: hash(normalized),
+    tools: normalized.map((tool) => ({ name: tool.name, hash: hash(tool) }))
+  };
+}
+function assertSnapshotFields(value, fields, location) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Client profile snapshot ${location} must be an object`);
+  }
+  const key = Object.keys(value).find((key2) => !fields.includes(key2));
+  if (key !== void 0) {
+    throw new Error(`Client profile snapshot contains unsupported fields at ${location}: ${JSON.stringify(key.slice(0, 128))}`);
+  }
+}
+function validateMcpFnClientProfileSnapshot(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Client profile snapshot must be an object");
+  }
+  assertSnapshotFields(value, ["formatVersion", "kind", "profile", "catalogHash", "tools"], "root");
+  const snapshot = value;
+  if (snapshot.formatVersion !== 1 || snapshot.kind !== "mcpfn.client-profile-snapshot") {
+    throw new Error("Unsupported client profile snapshot format");
+  }
+  if (!snapshot.profile)
+    throw new Error("Client profile snapshot requires profile metadata");
+  assertSnapshotFields(snapshot.profile, ["id", "version"], "profile");
+  assertProfileReference(snapshot.profile.id, snapshot.profile.version);
+  if (typeof snapshot.catalogHash !== "string" || !/^[a-f0-9]{64}$/.test(snapshot.catalogHash)) {
+    throw new Error("Client profile snapshot requires a SHA-256 catalogHash");
+  }
+  if (!Array.isArray(snapshot.tools))
+    throw new Error("Client profile snapshot tools must be an array");
+  let prior = "";
+  for (const [index, tool] of snapshot.tools.entries()) {
+    assertSnapshotFields(tool, ["name", "hash"], `tools[${index}]`);
+    if (!tool || typeof tool.name !== "string" || !tool.name || !/^[a-f0-9]{64}$/.test(tool.hash)) {
+      throw new Error("Client profile snapshot contains an invalid tool entry");
+    }
+    if (tool.name <= prior)
+      throw new Error(
+        "Client profile snapshot tools must be sorted and unique"
+      );
+    prior = tool.name;
+  }
+  return snapshot;
+}
+function diffMcpFnClientProfileSnapshots(beforeValue, afterValue) {
+  const before = validateMcpFnClientProfileSnapshot(beforeValue);
+  const after = validateMcpFnClientProfileSnapshot(afterValue);
+  if (before.profile.id !== after.profile.id) {
+    throw new Error("Cannot diff snapshots for different client profile ids");
+  }
+  const beforeByName = new Map(
+    before.tools.map((tool) => [tool.name, tool.hash])
+  );
+  const afterByName = new Map(
+    after.tools.map((tool) => [tool.name, tool.hash])
+  );
+  const names = [
+    .../* @__PURE__ */ new Set([...beforeByName.keys(), ...afterByName.keys()])
+  ].sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+  const changes = [];
+  for (const tool of names) {
+    const beforeHash = beforeByName.get(tool);
+    const afterHash = afterByName.get(tool);
+    if (!beforeHash) changes.push({ kind: "added", tool, afterHash });
+    else if (!afterHash) changes.push({ kind: "removed", tool, beforeHash });
+    else if (beforeHash !== afterHash) {
+      changes.push({ kind: "modified", tool, beforeHash, afterHash });
+    }
+  }
+  if (changes.length === 0 !== (before.catalogHash === after.catalogHash)) {
+    throw new Error("Inconsistent catalog hashes for tool entries");
+  }
+  const summary = {
+    added: changes.filter(({ kind }) => kind === "added").length,
+    removed: changes.filter(({ kind }) => kind === "removed").length,
+    modified: changes.filter(({ kind }) => kind === "modified").length
+  };
+  return { compatible: summary.removed === 0, changes, summary };
+}
+function createDialectValidator(dialect) {
+  const normalized = dialect.replace(/#$/, "");
+  if (normalized === "http://json-schema.org/draft-07/schema" || normalized === "https://json-schema.org/draft-07/schema")
+    return new Ajv({ allErrors: true, strict: false, validateFormats: false });
+  if (normalized === "http://json-schema.org/draft/2019-09/schema" || normalized === "https://json-schema.org/draft/2019-09/schema")
+    return new Ajv2019({
+      allErrors: true,
+      strict: false,
+      validateFormats: false
+    });
+  if (normalized === "http://json-schema.org/draft/2020-12/schema" || normalized === "https://json-schema.org/draft/2020-12/schema")
+    return new Ajv2020({
+      allErrors: true,
+      strict: false,
+      validateFormats: false
+    });
+  return void 0;
+}
+function pointerSegment(value) {
+  return value.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function walkSchema(value, path3, visit) {
+  if (!value || typeof value !== "object") return;
+  const schema = value;
+  for (const keyword of Object.keys(schema)) {
+    visit(keyword, `${path3}/${pointerSegment(keyword)}`, schema);
+  }
+  for (const mapKeyword of [
+    "$defs",
+    "definitions",
+    "dependencies",
+    "dependentSchemas",
+    "patternProperties",
+    "properties"
+  ]) {
+    const entries = schema[mapKeyword];
+    if (!entries || typeof entries !== "object" || Array.isArray(entries))
+      continue;
+    for (const [name, child] of Object.entries(
+      entries
+    )) {
+      walkSchema(child, `${path3}/${mapKeyword}/${pointerSegment(name)}`, visit);
+    }
+  }
+  for (const arrayKeyword of ["allOf", "anyOf", "oneOf", "prefixItems", "items"]) {
+    const entries = schema[arrayKeyword];
+    if (!Array.isArray(entries)) continue;
+    entries.forEach(
+      (child, index) => walkSchema(child, `${path3}/${arrayKeyword}/${index}`, visit)
+    );
+  }
+  for (const schemaKeyword of [
+    "additionalItems",
+    "additionalProperties",
+    "contains",
+    "contentSchema",
+    "else",
+    "if",
+    "items",
+    "not",
+    "propertyNames",
+    "then",
+    "unevaluatedItems",
+    "unevaluatedProperties"
+  ]) {
+    const child = schema[schemaKeyword];
+    if (child && typeof child === "object" && !Array.isArray(child)) {
+      walkSchema(child, `${path3}/${schemaKeyword}`, visit);
+    }
+  }
+}
+function validateMcpFnSchemaPortability(schema, path3, policy = {}) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+    return [
+      {
+        severity: "error",
+        code: "schema-invalid",
+        path: path3,
+        message: "Tool schema must be an object"
+      }
+    ];
+  }
+  const declared = schema.$schema;
+  const dialect = typeof declared === "string" ? declared : "http://json-schema.org/draft-07/schema#";
+  const validator = createDialectValidator(dialect);
+  if (!validator) {
+    return [
+      {
+        severity: "error",
+        code: "schema-dialect-unsupported",
+        path: `${path3}/$schema`,
+        message: boundedError(`Unsupported JSON Schema dialect ${dialect}`)
+      }
+    ];
+  }
+  const issues = [];
+  try {
+    validator.compile(schema);
+  } catch (error) {
+    issues.push({
+      severity: "error",
+      code: "schema-invalid",
+      path: path3,
+      message: boundedError(error)
+    });
+  }
+  const allowed = new Set(policy.allowKeywords ?? []);
+  const modernDialect = /draft\/(2019-09|2020-12)\/schema#?$/.test(dialect);
+  const assertionKeywords = /* @__PURE__ */ new Set([
+    "type",
+    "enum",
+    "const",
+    "multipleOf",
+    "maximum",
+    "exclusiveMaximum",
+    "minimum",
+    "exclusiveMinimum",
+    "maxLength",
+    "minLength",
+    "pattern",
+    "format",
+    "maxItems",
+    "minItems",
+    "uniqueItems",
+    "contains",
+    "minContains",
+    "maxContains",
+    "maxProperties",
+    "minProperties",
+    "required",
+    "dependentRequired",
+    "properties",
+    "patternProperties",
+    "additionalProperties",
+    "propertyNames",
+    "dependentSchemas",
+    "items",
+    "prefixItems",
+    "additionalItems",
+    "unevaluatedItems",
+    "unevaluatedProperties",
+    "allOf",
+    "anyOf",
+    "oneOf",
+    "not",
+    "if",
+    "then",
+    "else"
+  ]);
+  walkSchema(schema, path3, (keyword, keywordPath, node) => {
+    if (modernDialect && keyword === "$ref" && !allowed.has(keyword) && Object.keys(node).some((sibling) => assertionKeywords.has(sibling))) {
+      issues.push({
+        severity: policy.warningsAsErrors ? "error" : "warning",
+        code: "schema-portability-warning",
+        path: keywordPath,
+        keyword,
+        message: "$ref assertion siblings are evaluated by modern dialects but ignored by draft-07 clients"
+      });
+    }
+    if (!PORTABILITY_KEYWORDS.has(keyword) || allowed.has(keyword)) return;
+    issues.push({
+      severity: policy.warningsAsErrors ? "error" : "warning",
+      code: "schema-portability-warning",
+      path: keywordPath,
+      keyword,
+      message: `${keyword} is valid but may reduce client portability`
+    });
+  });
+  return issues.sort(
+    (left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0
+  );
+}
+function extractError(result) {
+  const structured = result.structuredContent;
+  if (structured?.error && typeof structured.error === "object") {
+    return structured.error;
+  }
+  const text = result.content.find((content) => content.type === "text")?.text;
+  if (!text) return void 0;
+  try {
+    const parsed = JSON.parse(text);
+    return parsed.error && typeof parsed.error === "object" ? parsed.error : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function fixtureFailure(result, fixture) {
+  const expected = fixture.expect;
+  if (fixture.source !== "captured-failure" && result.isError) return "Minimal-valid fixture returned isError=true";
+  if (fixture.source === "captured-failure" && !result.isError) return "Captured failure did not reproduce an error";
+  if (!expected)
+    return result.isError ? "Tool returned isError=true" : void 0;
+  if (expected.isError !== void 0 && Boolean(result.isError) !== expected.isError) {
+    return `Expected isError=${expected.isError}, received ${Boolean(result.isError)}`;
+  }
+  if (expected.structuredContent !== void 0 && stableJson(result.structuredContent) !== stableJson(expected.structuredContent))
+    return "Structured content did not match the fixture expectation";
+  const error = extractError(result);
+  if (expected.errorCode !== void 0 && error?.code !== expected.errorCode) {
+    return "Error code did not match the declared expectation";
+  }
+  const details = error?.details && typeof error.details === "object" ? error.details : void 0;
+  if (expected.lifecycleStage !== void 0 && details?.lifecycleStage !== expected.lifecycleStage)
+    return `Expected lifecycle stage ${expected.lifecycleStage}`;
+  if (expected.validationIssue) {
+    const issues = Array.isArray(details?.issues) ? details.issues : [];
+    const fields = Object.entries(expected.validationIssue).filter(([, value]) => value !== void 0);
+    const matched = fields.length > 0 && issues.some(
+      (issue) => fields.every(
+        ([key, value]) => issue[key] === value
+      )
+    );
+    if (!matched)
+      return "Expected structured validation issue was not reported";
+  }
+  return void 0;
+}
+async function runProfileCase(profileCase, allowSideEffects) {
+  const profile = { id: profileCase.id, version: profileCase.version };
+  let client;
+  let configurationError;
+  let pendingFailure;
+  let hasPendingFailure = false;
+  let cleanupOwner;
+  let result = {
+    profile,
+    status: "complete",
+    ok: false,
+    portability: [],
+    fixtures: []
+  };
+  try {
+    try {
+      client = await McpFnTestClient.connectTarget(
+        profileCase.target,
+        profileCase.clientInfo ?? {
+          name: "mcpfn-profile-suite",
+          version: "1.0.0"
+        },
+        { ...profileCase.client, capabilities: profileCase.capabilities }
+      );
+    } catch (error) {
+      if (error instanceof McpFnTestClientCleanupError) throw error;
+      return { ...result, phase: "connect", error: "Target connection failed" };
+    }
+    let tools;
+    try {
+      tools = await client.listTools();
+      const repeatedTools = await client.listTools();
+      if (stableJson(tools) !== stableJson(repeatedTools)) {
+        throw new Error(
+          "Effective catalog changed across identical profile list requests"
+        );
+      }
+      result.snapshot = createMcpFnClientProfileSnapshot(profile, tools);
+      result.snapshotMatches = profileCase.expectedSnapshot ? stableJson(result.snapshot) === stableJson(profileCase.expectedSnapshot) : void 0;
+      for (const tool of tools) {
+        result.portability.push(
+          ...validateMcpFnSchemaPortability(
+            tool.inputSchema,
+            `tools/${tool.name}/inputSchema`,
+            profileCase.portability
+          )
+        );
+        if (tool.outputSchema) {
+          result.portability.push(
+            ...validateMcpFnSchemaPortability(
+              tool.outputSchema,
+              `tools/${tool.name}/outputSchema`,
+              profileCase.portability
+            )
+          );
+        }
+      }
+    } catch (error) {
+      tools = void 0;
+      result = { ...result, phase: "catalog", error: "Target catalog validation failed" };
+    }
+    if (tools) {
+      const advertised = new Set(tools.map(({ name }) => name));
+      const taskRequired = new Set(tools.filter((tool) => tool.execution?.taskSupport === "required").map((tool) => tool.name));
+      if (profileCase.fixtures?.some((fixture) => taskRequired.has(fixture.tool))) {
+        configurationError = new Error(`Client profile ${profile.id}@${profile.version} task-required fixtures are unsupported by this contract runner`);
+        throw configurationError;
+      }
+      for (const fixture of profileCase.fixtures ?? []) {
+        const base = {
+          name: fixture.name,
+          tool: fixture.tool,
+          source: fixture.source ?? "minimal-valid"
+        };
+        if (!advertised.has(fixture.tool)) {
+          result.fixtures.push({
+            ...base,
+            status: "failed",
+            code: "fixture-tool-not-advertised",
+            error: "Fixture references a tool absent from the effective catalog"
+          });
+          continue;
+        }
+        if (fixture.sideEffect !== "read-only" && !allowSideEffects) {
+          result.fixtures.push({
+            ...base,
+            status: "incomplete",
+            code: "side-effect-not-authorized",
+            error: "Fixture was not executed because side effects were not explicitly allowed"
+          });
+          continue;
+        }
+        try {
+          const callResult = await client.callTool(
+            fixture.tool,
+            fixture.arguments ?? {}
+          );
+          const failure = fixtureFailure(callResult, fixture);
+          result.fixtures.push(
+            failure ? {
+              ...base,
+              status: "failed",
+              code: "fixture-expectation-failed",
+              error: failure
+            } : { ...base, status: "passed" }
+          );
+        } catch (error) {
+          result.fixtures.push({
+            ...base,
+            status: "failed",
+            code: "fixture-call-failed",
+            error: "Tool invocation failed; argument values and exception text are omitted"
+          });
+        }
+      }
+      const incomplete = result.fixtures.some(
+        ({ status }) => status === "incomplete"
+      );
+      const failed = result.fixtures.some(({ status }) => status === "failed") || result.portability.some(({ severity }) => severity === "error") || result.snapshotMatches === false;
+      result = {
+        ...result,
+        phase: result.snapshotMatches === false || result.portability.some(({ severity }) => severity === "error") ? "catalog" : failed || incomplete ? "fixtures" : void 0,
+        status: incomplete ? "incomplete" : "complete",
+        ok: !failed && !incomplete,
+        ...result.snapshotMatches === false ? {
+          error: "Effective catalog does not match the reviewed profile snapshot"
+        } : {}
+      };
+    }
+  } catch (error) {
+    pendingFailure = error;
+    hasPendingFailure = true;
+  } finally {
+    if (client) {
+      try {
+        await client.close();
+      } catch (error) {
+        if (error instanceof McpFnTestClientCleanupError) cleanupOwner = error;
+        else {
+          if (configurationError) configurationError.message = `${configurationError.message}; target cleanup failed`;
+          result = {
+            ...result,
+            ok: false,
+            phase: result.phase ?? "close",
+            error: result.error ? `${result.error}; target cleanup failed`.slice(0, 512) : "Target cleanup failed"
+          };
+        }
+      }
+    }
+  }
+  if (cleanupOwner) throw new ProfileCaseCleanupError(cleanupOwner, {
+    ...result,
+    ok: false,
+    status: "incomplete",
+    phase: result.phase ?? (hasPendingFailure ? "fixtures" : "close"),
+    error: hasPendingFailure ? "Profile execution failed; target cleanup remains pending" : "Target cleanup remains pending"
+  });
+  if (hasPendingFailure) {
+    if (pendingFailure instanceof McpFnTestClientCleanupError) {
+      throw new ProfileCaseCleanupError(pendingFailure, {
+        ...result,
+        ok: false,
+        status: "incomplete",
+        phase: "connect",
+        error: "Target cleanup remains pending"
+      });
+    }
+    throw pendingFailure;
+  }
+  return result;
+}
+async function runMcpFnClientProfileContracts(options) {
+  const maxReportBytes = options.maxReportBytes ?? 1048576;
+  if (!Number.isSafeInteger(maxReportBytes) || maxReportBytes < 2048) {
+    throw new Error("maxReportBytes must be an integer of at least 2048");
+  }
+  if (!Array.isArray(options.profiles) || options.profiles.length === 0) {
+    throw new Error(
+      "At least one generic or configured client profile is required"
+    );
+  }
+  if (options.profiles.length > 100)
+    throw new Error("At most 100 client profiles may be tested");
+  const keys = /* @__PURE__ */ new Set();
+  for (const profile of options.profiles) {
+    assertProfileReference(profile.id, profile.version);
+    const key = `${profile.id}@${profile.version}`;
+    if (keys.has(key)) throw new Error(`Duplicate client profile case ${key}`);
+    keys.add(key);
+    if (profile.expectedSnapshot)
+      validateMcpFnClientProfileSnapshot(profile.expectedSnapshot);
+    for (const fixture of profile.fixtures ?? []) {
+      if (fixture.source === "captured-failure" && (!fixture.expect || fixture.expect.isError === false || !(fixture.expect.structuredContent !== void 0 || fixture.expect.errorCode || fixture.expect.lifecycleStage || fixture.expect.validationIssue && Object.values(fixture.expect.validationIssue).some((value) => value !== void 0)))) {
+        throw new Error(`Captured-failure fixture ${fixture.name} requires meaningful error expectations`);
+      }
+      if (fixture.source !== void 0 && !["minimal-valid", "captured-failure"].includes(fixture.source)) throw new Error("Invalid fixture source");
+      if (!fixture.name || !fixture.tool || !["read-only", "idempotent", "non-idempotent"].includes(fixture.sideEffect)) {
+        throw new Error(`Client profile ${key} contains an invalid fixture`);
+      }
+    }
+  }
+  const profiles = [];
+  const cleanupOwners = [];
+  for (const profile of [...options.profiles].sort((left, right) => {
+    const leftKey = `${left.id}@${left.version}`;
+    const rightKey = `${right.id}@${right.version}`;
+    return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
+  })) {
+    try {
+      profiles.push(await runProfileCase(profile, options.allowSideEffects === true));
+    } catch (error) {
+      if (error instanceof ProfileCaseCleanupError) {
+        profiles.push(error.result);
+        cleanupOwners.push(error.owner);
+      } else {
+        if (cleanupOwners.length === 0) throw error;
+        profiles.push({
+          profile: { id: profile.id, version: profile.version },
+          status: "incomplete",
+          ok: false,
+          phase: "fixtures",
+          portability: [],
+          fixtures: [],
+          error: "Profile execution failed"
+        });
+      }
+    }
+  }
+  const report = {
+    formatVersion: 1,
+    kind: "mcpfn.client-profile-contract-report",
+    status: profiles.some(({ status }) => status === "incomplete") ? "incomplete" : "complete",
+    ok: profiles.every(({ ok }) => ok),
+    profiles,
+    droppedProfiles: 0
+  };
+  if (new TextEncoder().encode(JSON.stringify(report)).byteLength <= maxReportBytes)
+    return finishReport(report, cleanupOwners);
+  report.ok = false;
+  report.status = "incomplete";
+  report.incompleteReason = "Report content exceeded maxReportBytes and was truncated";
+  while (new TextEncoder().encode(JSON.stringify(report)).byteLength > maxReportBytes && report.profiles.length > 0) {
+    report.profiles.pop();
+    report.droppedProfiles += 1;
+  }
+  if (new TextEncoder().encode(JSON.stringify(report)).byteLength > maxReportBytes) {
+    throw new Error("The minimum client profile report exceeds maxReportBytes");
+  }
+  return finishReport(report, cleanupOwners);
+}
+function finishReport(report, cleanupOwners) {
+  if (cleanupOwners.length) throw new McpFnClientProfileContractCleanupError(report, cleanupOwners);
+  return report;
+}
+
+// src/conformance-process.ts
+import { execFile } from "child_process";
+import path from "path";
+async function terminateConformanceRunner(child, platform = process.platform, systemRoot = process.env.SystemRoot) {
+  const killWrapper = () => {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+  };
+  try {
+    if (platform === "win32" && child.pid) {
+      if (!systemRoot || !path.win32.isAbsolute(systemRoot)) {
+        killWrapper();
+        return;
+      }
+      await new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          killWrapper();
+          resolve();
+        }, 2500);
+        const done = (error) => {
+          clearTimeout(timer);
+          if (error) killWrapper();
+          resolve();
+        };
+        try {
+          execFile(
+            path.win32.join(systemRoot, "System32", "taskkill.exe"),
+            ["/pid", String(child.pid), "/T", "/F"],
+            { timeout: 2e3, windowsHide: true },
+            done
+          );
+        } catch (error) {
+          done(error);
+        }
+      });
+    } else if (child.pid) {
+      try {
+        process.kill(-child.pid, "SIGKILL");
+      } catch (error) {
+        if (error.code !== "ESRCH") killWrapper();
+      }
+    } else killWrapper();
+  } finally {
+    child.stdout?.destroy();
+    child.stderr?.destroy();
+  }
+}
+
 // src/conformance.ts
 import { spawn } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
 import { existsSync } from "fs";
 import {
   createServer as createServer2,
   request as httpRequest
 } from "http";
 import { request as httpsRequest } from "https";
-import path from "path";
+import path2 from "path";
+import { redactOAuthValue as redactOAuthValue4 } from "@superfunctions/oauth-core";
+
+// src/remote-target.ts
+import {
+  McpFnClientError,
+  customTarget as customTarget2,
+  streamableHttpTarget
+} from "@mcpfn/client";
+import { redactOAuthValue as redactOAuthValue2 } from "@superfunctions/oauth-core";
+var targetSecrets = /* @__PURE__ */ new WeakMap();
+var utf8Encoder = new TextEncoder();
+function beginTargetCredentialRedaction(target) {
+  const state = targetSecrets.get(target);
+  if (!state) return () => void 0;
+  const scope = new Set(state.active.keys());
+  state.scopes.add(scope);
+  return () => {
+    state.scopes.delete(scope);
+    scope.clear();
+  };
+}
+function credentialValues(headers) {
+  const values = boundedCredentialEntries(headers);
+  const secrets = /* @__PURE__ */ new Set();
+  for (const [header, raw] of values) {
+    if (!raw.trim()) continue;
+    secrets.add(raw);
+    secrets.add(raw.trim());
+    const normalizedHeader = header.toLowerCase();
+    if (["authorization", "proxy-authorization"].includes(normalizedHeader)) {
+      addAuthorizationSecrets(raw, secrets);
+    }
+    if (normalizedHeader === "cookie") addCookieSecrets(raw, secrets);
+  }
+  return secrets;
+}
+function addAuthorizationSecrets(raw, secrets) {
+  const trimmed = raw.trim();
+  const separator = trimmed.search(/\s/);
+  if (separator <= 0) return;
+  const scheme = trimmed.slice(0, separator).toLowerCase();
+  const token = trimmed.slice(separator).trim();
+  if (token) secrets.add(token);
+  if (scheme !== "basic") {
+    if (scheme !== "bearer" && !authorizationToken68.test(token)) {
+      addAuthorizationParameterSecrets(token, secrets);
+    }
+    return;
+  }
+  addBasicAuthorizationSecrets(token, secrets);
+}
+function addBasicAuthorizationSecrets(token, secrets) {
+  if (!/^[\dA-Za-z+/]+={0,2}$/.test(token)) return;
+  const decoded = Buffer.from(token, "base64");
+  if (stripBase64Padding(decoded.toString("base64")) !== stripBase64Padding(token)) return;
+  for (const encoding of ["utf8", "latin1"]) {
+    const pair = decoded.toString(encoding);
+    const colon = pair.indexOf(":");
+    if (colon < 0) continue;
+    for (const value of [pair, pair.slice(0, colon), pair.slice(colon + 1)]) {
+      if (value) secrets.add(value);
+    }
+  }
+}
+var authorizationToken68 = /^[\dA-Za-z._~+\x2F-]+=*$/;
+var authorizationParameterName = /^[!#$%&'*+.^_`|~\dA-Za-z-]+$/;
+function skipAuthorizationWhitespace(token, cursor) {
+  while (token[cursor] === " " || token[cursor] === "	") cursor += 1;
+  return cursor;
+}
+function parseQuotedAuthorizationValue(token, start) {
+  let cursor = start + 1;
+  let decoded = "";
+  while (cursor < token.length && token[cursor] !== '"') {
+    if (token[cursor] === "\\") {
+      cursor += 1;
+      if (cursor >= token.length) {
+        throw new TypeError("Authorization credential parameters must use balanced quotes");
+      }
+    }
+    decoded += token[cursor];
+    cursor += 1;
+  }
+  if (token[cursor] !== '"') {
+    throw new TypeError("Authorization credential parameters must use balanced quotes");
+  }
+  cursor += 1;
+  const rawValue = token.slice(start, cursor);
+  return {
+    cursor,
+    components: [rawValue, rawValue.slice(1, -1), decoded].filter(Boolean)
+  };
+}
+function parseUnquotedAuthorizationValue(token, start) {
+  let cursor = start;
+  while (cursor < token.length && token[cursor] !== ",") cursor += 1;
+  const value = token.slice(start, cursor).trim();
+  if (!value || /\s/.test(value) || value.includes('"')) {
+    throw new TypeError("Authorization credential parameters must contain valid values");
+  }
+  return { cursor, components: [value] };
+}
+function parseAuthorizationParameter(token, start) {
+  let cursor = skipAuthorizationWhitespace(token, start);
+  const nameStart = cursor;
+  while (cursor < token.length && token[cursor] !== "=" && token[cursor] !== " " && token[cursor] !== "	" && token[cursor] !== ",") cursor += 1;
+  const name = token.slice(nameStart, cursor);
+  cursor = skipAuthorizationWhitespace(token, cursor);
+  if (!authorizationParameterName.test(name) || token[cursor] !== "=") {
+    throw new TypeError("Authorization credential parameters must use name=value syntax");
+  }
+  cursor = skipAuthorizationWhitespace(token, cursor + 1);
+  if (cursor >= token.length) {
+    throw new TypeError("Authorization credential parameters must contain values");
+  }
+  const parsed = token[cursor] === '"' ? parseQuotedAuthorizationValue(token, cursor) : parseUnquotedAuthorizationValue(token, cursor);
+  return { ...parsed, cursor: skipAuthorizationWhitespace(token, parsed.cursor) };
+}
+function addAuthorizationParameterSecrets(token, secrets) {
+  const firstEquals = token.indexOf("=");
+  if (firstEquals < 1 || !authorizationParameterName.test(token.slice(0, firstEquals).trim())) return;
+  let cursor = 0;
+  while (cursor < token.length) {
+    const parsed = parseAuthorizationParameter(token, cursor);
+    for (const component of parsed.components) secrets.add(component);
+    cursor = parsed.cursor;
+    if (cursor === token.length) return;
+    if (token[cursor] !== ",") {
+      throw new TypeError("Authorization credential parameters must be comma separated");
+    }
+    cursor = skipAuthorizationWhitespace(token, cursor + 1);
+    if (cursor === token.length) {
+      throw new TypeError("Authorization credential parameters must not end with a comma");
+    }
+  }
+}
+function stripBase64Padding(value) {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === "=") end -= 1;
+  return value.slice(0, end);
+}
+function addCookieSecrets(raw, secrets) {
+  for (const part of raw.split(/[;,]/)) {
+    const pair = part.trim();
+    if (!pair) continue;
+    const equals = pair.indexOf("=");
+    if (equals < 1) {
+      throw new TypeError("Cookie credential headers must contain name=value pairs");
+    }
+    const value = pair.slice(equals + 1).trim();
+    if (!value) continue;
+    secrets.add(value);
+    addUnquotedCookieSecret(value, secrets);
+  }
+}
+function addUnquotedCookieSecret(value, secrets) {
+  if (!value.startsWith('"') && !value.endsWith('"')) return;
+  if (value.length < 2 || !value.startsWith('"') || !value.endsWith('"')) {
+    throw new TypeError("Cookie credential values must use balanced quotes");
+  }
+  const unquoted = value.slice(1, -1);
+  if (unquoted.includes('"') || unquoted.includes("\\")) {
+    throw new TypeError("Cookie credential values must use RFC 6265 syntax");
+  }
+  if (unquoted) secrets.add(unquoted);
+}
+var McpFnRedactionLimitError = class extends Error {
+  constructor(message = "Credential redaction exceeded its traversal budget") {
+    super(message);
+  }
+};
+var McpFnStructuralCredentialCollisionError = class extends McpFnRedactionLimitError {
+  constructor() {
+    super("Credential collides with required artifact structure");
+  }
+};
+var envelopeKeys = Object.fromEntries(Object.entries({
+  root: "formatVersion kind artifactValidation status runtime ok target server capabilities manifestChecked manifestHash total passed failed incomplete droppedResults droppedObservedEvents redactionOmittedObservedEvents incompleteReason failure timeline droppedTimelineEvents results count clientState tools resources resourceTemplates prompts droppedEvents timelineComplete droppedInventoryEntries inventoryComplete suiteVersion exitCode stdout stderr phase outcome code requestId at details payload",
+  result: "formatVersion name operation tool status sideEffect durationMs error droppedObservedEvents redactionOmittedObservedEvents",
+  diagnostic: "phase outcome code requestId at target details",
+  inspectorEvent: "formatVersion source kind at event",
+  failure: "name message layer code phase details",
+  runtime: "node scenarioFormatVersion reportSchemaVersion packages",
+  packages: "testing",
+  droppedInventoryEntries: "tools resources resourceTemplates prompts",
+  target: "kind"
+}).map(([role, keys]) => [role, new Set(keys.split(" "))]));
+var structuralArtifactValues = new Map([
+  ["root:kind", /* @__PURE__ */ new Set(["logging.message", "progress", "tasks.status", "resources.updated", "tools.list_changed", "resources.list_changed", "prompts.list_changed", "resources.subscribed", "resources.unsubscribed", "client.roots", "client.sampling", "client.elicitation", "mcpfn.target-suite-report", "mcpfn.inspector-snapshot", "mcpfn.official-conformance-report"])],
+  ["inspectorEvent:kind", /* @__PURE__ */ new Set(["logging.message", "progress", "tasks.status", "resources.updated", "tools.list_changed", "resources.list_changed", "prompts.list_changed", "resources.subscribed", "resources.unsubscribed", "client.roots", "client.sampling", "client.elicitation"])],
+  ["root:clientState", /* @__PURE__ */ new Set(["idle", "connecting", "authorization-required", "connected", "closing", "closed"])],
+  ["target:kind", /* @__PURE__ */ new Set(["authenticated-streamable-http", "streamable-http", "stdio", "in-memory", "custom"])],
+  ["root:status", /* @__PURE__ */ new Set(["passed", "failed", "incomplete", "complete"])],
+  ["result:status", /* @__PURE__ */ new Set(["passed", "failed", "incomplete", "complete"])],
+  ["root:outcome", /* @__PURE__ */ new Set(["started", "succeeded", "failed"])],
+  ["diagnostic:outcome", /* @__PURE__ */ new Set(["started", "succeeded", "failed"])],
+  ...["root", "diagnostic", "failure"].map((role) => [
+    `${role}:phase`,
+    /* @__PURE__ */ new Set(["resource-discovery", "authorization-server-discovery", "client-registration", "authorization-request", "authorization-callback", "token-exchange", "token-refresh", "token-revocation", "transport-connect", "mcp-initialize", "capability-operation", "transport-close"])
+  ]),
+  ["failure:layer", /* @__PURE__ */ new Set(["mcpfn-preflight", "authorization-server", "resource-server", "mcp-initialization", "scenario", "upstream-conformance"])],
+  ["inspectorEvent:source", /* @__PURE__ */ new Set(["diagnostic", "client"])],
+  ["result:sideEffect", /* @__PURE__ */ new Set(["none", "idempotent", "non-idempotent"])]
+]);
+var unrestrictedStructuralValueFields = /* @__PURE__ */ new Set([
+  "packages:testing",
+  "runtime:node",
+  "runtime:reportSchemaVersion",
+  "root:suiteVersion"
+]);
+function childEnvelopeRole(fixed, key, role, input, rootKind) {
+  if (!fixed) return "payload";
+  if (key === "results") return "result";
+  if (key === "timeline") {
+    return rootKind === "mcpfn.inspector-snapshot" ? "inspectorEvent" : "diagnostic";
+  }
+  if (["failure", "runtime", "packages", "droppedInventoryEntries", "target"].includes(key)) {
+    return key;
+  }
+  if (role === "inspectorEvent" && key === "event") {
+    return input.source === "client" ? "root" : "diagnostic";
+  }
+  return "payload";
+}
+function specialValue(input) {
+  if (input instanceof Error) return normalizeErrorValue(input);
+  if (input instanceof Date) return Number.isNaN(input.getTime()) ? "Invalid Date" : input.toISOString();
+  if (input instanceof URL) return input.href;
+  if (input instanceof Map) {
+    if (Object.getOwnPropertyDescriptor(Map.prototype, "size").get.call(input) > 1e5) throw new McpFnRedactionLimitError();
+    return { type: "Map", entries: [...Map.prototype.entries.call(input)] };
+  }
+  if (input instanceof Set) {
+    if (Object.getOwnPropertyDescriptor(Set.prototype, "size").get.call(input) > 1e5) throw new McpFnRedactionLimitError();
+    return { type: "Set", values: [...Set.prototype.values.call(input)] };
+  }
+  return input;
+}
+function normalizeErrorValue(input) {
+  const normalized = /* @__PURE__ */ Object.create(null);
+  let enumerableFields = 0;
+  for (const key in input) {
+    if (!Object.hasOwn(input, key)) continue;
+    if (++enumerableFields > 1e5) throw new McpFnRedactionLimitError();
+    normalized[key] = input[key];
+  }
+  normalized.name = input.name;
+  normalized.message = input.message;
+  normalized.stack = input.stack;
+  if (input.cause !== void 0) normalized.cause = input.cause;
+  return normalized;
+}
+function credentialPatterns(values) {
+  const variants = [...values].filter(Boolean).flatMap((secret) => [
+    { value: secret, encoded: false },
+    { value: JSON.stringify(secret).slice(1, -1), encoded: false },
+    { value: encodeURIComponent(secret), encoded: true },
+    { value: new URLSearchParams({ value: secret }).toString().slice("value=".length), encoded: true }
+  ]).sort((a, b) => b.value.length - a.value.length);
+  const patterns = variants.map(({ value, encoded }) => {
+    const literal = value.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+    return encoded ? literal.replace(/%[\dA-Fa-f]{2}/g, (escape) => escape.replace(/[A-Fa-f]/g, (hex) => `[${hex.toLowerCase()}${hex.toUpperCase()}]`)) : literal;
+  });
+  return {
+    secretPattern: patterns.length ? new RegExp(patterns.join("|"), "g") : void 0,
+    replacementPattern: patterns.length ? new RegExp(patterns.join("|")) : void 0
+  };
+}
+function targetCredentialValues(target) {
+  const state = targetSecrets.get(target);
+  return /* @__PURE__ */ new Set([
+    ...state?.active.keys() ?? [],
+    ...[...state?.scopes ?? []].flatMap((scope) => [...scope])
+  ]);
+}
+function scrubCredentials(value, values, preserveKeys = false, redactionMarker) {
+  let entries = 0, stringBytes = 0;
+  const budget = (input, depth = 0) => {
+    input = specialValue(input);
+    if (Array.isArray(input) && input.length > 1e5 || ++entries > 1e5 || depth > 32) throw new McpFnRedactionLimitError();
+    if (typeof input === "string") {
+      stringBytes += Buffer.byteLength(input);
+      if (input.length > 262144 || stringBytes > 2097152) throw new McpFnRedactionLimitError();
+    } else if (input && typeof input === "object") {
+      for (const key in input) if (Object.hasOwn(input, key)) {
+        budget(key, depth + 1);
+        budget(input[key], depth + 1);
+      }
+    }
+  };
+  budget(value);
+  const { secretPattern, replacementPattern } = credentialPatterns(values);
+  const preserveStructural = (input) => {
+    if (replacementPattern?.test(input)) {
+      throw new McpFnRedactionLimitError(
+        "Credential collides with a required structural artifact field"
+      );
+    }
+    return input;
+  };
+  const preserveStructuralKey = (input) => {
+    if (replacementPattern?.test(input)) {
+      throw new McpFnStructuralCredentialCollisionError();
+    }
+    return input;
+  };
+  if (secretPattern) {
+    const markerContainsSecret = secretPattern.test(redactionMarker ?? "[REDACTED]");
+    secretPattern.lastIndex = 0;
+    if (markerContainsSecret) redactionMarker = "";
+  }
+  const scrubString = (input, role2, field, finalPass) => {
+    const structuralField = `${role2}:${field}`;
+    if (unrestrictedStructuralValueFields.has(structuralField) || structuralArtifactValues.get(structuralField)?.has(input)) {
+      return preserveStructural(input);
+    }
+    if (finalPass) return replacementPattern?.test(input) ? "" : input;
+    if (!secretPattern) return input;
+    return input.replace(secretPattern, (secret) => {
+      const maskCharacter = secret.includes("*") ? "#" : "*";
+      const defaultReplacement = secret.length < 10 ? maskCharacter.repeat(secret.length) : "[REDACTED]";
+      const replacement = redactionMarker ?? defaultReplacement;
+      return replacementPattern.test(replacement) ? "" : replacement;
+    });
+  };
+  function scrubArray(input, role2, finalPass) {
+    const result2 = input.map((entry) => scrub(entry, role2, "", finalPass));
+    assertPayloadSerialization(result2, role2, finalPass, replacementPattern);
+    return result2;
+  }
+  function scrubObject(input, role2, finalPass) {
+    const entries2 = [];
+    const keys = /* @__PURE__ */ new Set();
+    for (const [key, entry] of Object.entries(input)) {
+      const fixed = envelopeKeys[role2]?.has(key) ?? false;
+      if (fixed) preserveStructuralKey(key);
+      const childRole = childEnvelopeRole(
+        fixed,
+        key,
+        role2,
+        input,
+        value?.kind
+      );
+      const scrubbedKey = fixed ? key : scrub(key, "payload", "", finalPass);
+      if (keys.has(scrubbedKey)) {
+        throw new McpFnRedactionLimitError(
+          "Credential redaction created duplicate object keys"
+        );
+      }
+      keys.add(scrubbedKey);
+      const entryRole = fixed ? role2 : "payload";
+      const scrubbedEntry = typeof entry === "string" ? scrub(entry, entryRole, key, finalPass) : scrub(entry, childRole, "", finalPass);
+      entries2.push([scrubbedKey, scrubbedEntry]);
+    }
+    const result2 = Object.fromEntries(entries2);
+    assertPayloadSerialization(result2, role2, finalPass, replacementPattern);
+    return result2;
+  }
+  function scrub(input, role2 = "payload", field = "", finalPass = false) {
+    input = specialValue(input);
+    if (typeof input === "string") return scrubString(input, role2, field, finalPass);
+    if (Array.isArray(input)) return scrubArray(input, role2, finalPass);
+    if (input && typeof input === "object") {
+      return scrubObject(input, role2, finalPass);
+    }
+    return input;
+  }
+  const timelineEvent = value && typeof value === "object" && ["client", "diagnostic"].includes(value.source ?? "");
+  let role = "payload";
+  if (preserveKeys) role = timelineEvent ? "inspectorEvent" : "root";
+  const scrubbed = scrub(value, role);
+  const generic = redactOAuthValue2(scrubbed, { maxStringLength: 262144, maxDepth: 64, maxArrayEntries: 1e5, maxObjectEntries: 1e5, ...redactionMarker !== void 0 ? { redactionMarker } : {} });
+  const result = scrub(generic, role, "", true);
+  assertPayloadSerialization(
+    result,
+    "payload",
+    true,
+    replacementPattern
+  );
+  return result;
+}
+function assertPayloadSerialization(value, role, finalPass, credentialPattern) {
+  if (!finalPass || role !== "payload" || !credentialPattern) return;
+  const serialized = JSON.stringify(value);
+  if (serialized !== void 0 && credentialPattern.test(serialized)) {
+    throw new McpFnRedactionLimitError(
+      "Credential redaction could not guarantee safe serialized output"
+    );
+  }
+}
+function redactTargetCredentials(target, value, options = {}) {
+  return scrubCredentials(
+    value,
+    targetCredentialValues(target),
+    options.preserveKeys,
+    options.redactionMarker
+  );
+}
+function assertTargetArtifactSafe(target, value) {
+  const { replacementPattern } = credentialPatterns(targetCredentialValues(target));
+  if (replacementPattern?.test(value)) {
+    throw new McpFnRedactionLimitError(
+      "Credential redaction could not guarantee safe serialized output"
+    );
+  }
+}
+function redactRemoteCredential(credential, value, options = {}) {
+  return scrubCredentials(value, credentialValues(credential.headers), options.preserveKeys);
+}
+var MAX_CREDENTIAL_HEADERS = 32;
+var MAX_CREDENTIAL_HEADER_BYTES = 16384;
+var MAX_CREDENTIAL_HEADER_VALUE_BYTES = 8192;
+var FORBIDDEN_CREDENTIAL_HEADERS = /* @__PURE__ */ new Set([
+  "connection",
+  "content-length",
+  "host",
+  "proxy-connection",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+function staticRemoteCredentialProvider(credential) {
+  return { acquire: () => credential };
+}
+async function acquireRemoteCredential(source, context) {
+  let provider;
+  let acquired;
+  try {
+    provider = isCredentialProvider(source) ? source : staticRemoteCredentialProvider(source);
+    acquired = await provider.acquire(context);
+  } catch {
+    throw new Error("Target credential acquisition failed");
+  }
+  let credential = acquired;
+  try {
+    credential = { ...acquired, headers: boundedCredentialEntries(acquired.headers) };
+  } catch {
+  }
+  let releasePromise;
+  let revoked = false;
+  let disposed = false;
+  let cleanupPhase = credential.kind === "oauth" ? "token-revocation" : "transport-close";
+  return {
+    credential,
+    cleanupPhase: () => cleanupPhase,
+    release() {
+      releasePromise ??= (async () => {
+        const cleanupContext = { ...context, signal: new AbortController().signal };
+        try {
+          if (!revoked) {
+            cleanupPhase = credential.kind === "oauth" ? "token-revocation" : "transport-close";
+            await provider.revoke?.(acquired, cleanupContext);
+            revoked = true;
+          }
+          if (!disposed) {
+            cleanupPhase = "transport-close";
+            await provider.dispose?.(acquired, cleanupContext);
+            disposed = true;
+          }
+        } catch {
+          throw new McpFnClientError(
+            "MCPFN_OPERATION_FAILED",
+            "Target credential cleanup failed",
+            { phase: cleanupPhase, retryable: true }
+          );
+        }
+      })().catch((error) => {
+        releasePromise = void 0;
+        throw error;
+      });
+      return releasePromise;
+    }
+  };
+}
+function authenticatedHttpTarget(url, options) {
+  const targetUrl = normalizeRemoteTargetUrl(url);
+  const descriptorUrl = new URL(targetUrl);
+  descriptorUrl.search = "";
+  const { credential: _credential, requestInit, ...transportOptions } = options;
+  const state = { active: /* @__PURE__ */ new Map(), scopes: /* @__PURE__ */ new Set() };
+  const pendingReleases = /* @__PURE__ */ new Set();
+  const authenticated = customTarget2({
+    kind: "authenticated-streamable-http",
+    descriptor: {
+      url: descriptorUrl.toString(),
+      authenticated: true
+    },
+    redact: (value, redaction) => redactTargetCredentials(authenticated, value, { preserveKeys: true, ...redaction }),
+    assertArtifactSafe: (value) => assertTargetArtifactSafe(authenticated, value),
+    beginRedactionScope: () => beginTargetCredentialRedaction(authenticated),
+    async cleanup() {
+      const results = await Promise.allSettled([...pendingReleases].map((release) => release()));
+      const failures = results.filter((result) => result.status === "rejected");
+      const failure = failures.find(({ reason }) => reason && typeof reason === "object" && reason.phase === "token-revocation") ?? failures[0];
+      if (failure) throw failure.reason;
+    },
+    async open(targetContext) {
+      const context = {
+        url: targetUrl.toString(),
+        requestId: targetContext.requestId,
+        signal: targetContext.signal
+      };
+      const lease = await acquireRemoteCredential(options.credential, context);
+      const secrets = /* @__PURE__ */ new Set();
+      const release = async () => {
+        try {
+          await lease.release();
+        } catch (error) {
+          pendingReleases.add(release);
+          throw error;
+        }
+        pendingReleases.delete(release);
+        for (const secret of secrets) {
+          const count = (state.active.get(secret) ?? 1) - 1;
+          if (count) state.active.set(secret, count);
+          else state.active.delete(secret);
+        }
+        secrets.clear();
+      };
+      let handle;
+      try {
+        for (const secret of credentialValues(lease.credential.headers)) {
+          secrets.add(secret);
+          state.active.set(secret, (state.active.get(secret) ?? 0) + 1);
+          for (const scope of state.scopes) scope.add(secret);
+        }
+        const credentialHeaders = validateRemoteCredentialHeaders(lease.credential.headers);
+        const headers = new Headers(requestInit?.headers);
+        credentialHeaders.forEach((value, name) => headers.set(name, value));
+        const target = streamableHttpTarget(targetUrl, {
+          ...transportOptions,
+          requestInit: {
+            ...requestInit,
+            headers,
+            // Fetch must not replay credentials to a redirect destination.
+            redirect: "error"
+          }
+        });
+        handle = await target.open(targetContext);
+      } catch (error) {
+        let message = "Authenticated target could not be opened";
+        try {
+          message = redactRemoteCredential(lease.credential, error instanceof Error ? error.message : String(error));
+        } catch {
+        }
+        pendingReleases.add(release);
+        await release();
+        throw new Error(message);
+      }
+      let closePromise;
+      let transportClosed = false;
+      return {
+        transport: handle.transport,
+        finishAuthorization: handle.finishAuthorization,
+        terminateSession: handle.terminateSession,
+        close() {
+          closePromise ??= Promise.resolve().then(async () => {
+            if (!transportClosed) {
+              if (handle.close) await handle.close();
+              else await handle.transport.close();
+              transportClosed = true;
+            }
+            await release();
+          }).catch(async (error) => {
+            closePromise = void 0;
+            const phase = transportClosed ? lease.cleanupPhase() : "transport-close";
+            await targetContext.diagnostic({
+              phase,
+              outcome: "failed",
+              code: "MCPFN_CREDENTIAL_CLEANUP_FAILED",
+              requestId: targetContext.requestId,
+              at: (/* @__PURE__ */ new Date()).toISOString(),
+              target: { kind: "authenticated-streamable-http", url: descriptorUrl.toString() },
+              details: { message: "Target credential cleanup failed" }
+            });
+            throw error;
+          });
+          return closePromise;
+        }
+      };
+    }
+  });
+  targetSecrets.set(authenticated, state);
+  return authenticated;
+}
+function normalizeRemoteTargetUrl(value) {
+  const url = new URL(value.toString());
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new TypeError("Authenticated MCP targets must use HTTP or HTTPS");
+  }
+  if (url.protocol === "http:" && url.hostname !== "[::1]" && !/^127(?:\.\d{1,3}){3}$/.test(url.hostname)) {
+    throw new TypeError("Credential-bearing HTTP targets require a literal loopback address; use HTTPS remotely");
+  }
+  if (url.username || url.password || url.hash) {
+    throw new TypeError(
+      "Authenticated MCP target URLs must not contain userinfo or a fragment"
+    );
+  }
+  return url;
+}
+function isCredentialProvider(value) {
+  return "acquire" in value && typeof value.acquire === "function";
+}
+function boundedCredentialEntries(value) {
+  const entries = [];
+  let bytes2 = 0;
+  const append = (name, headerValue) => {
+    if (entries.length >= MAX_CREDENTIAL_HEADERS) throw new TypeError("Credential headers exceed the header limit");
+    if (typeof name !== "string" || typeof headerValue !== "string") throw new TypeError("Credential header values must be strings");
+    if (name.length > MAX_CREDENTIAL_HEADER_BYTES || headerValue.length > MAX_CREDENTIAL_HEADER_VALUE_BYTES) throw new TypeError("Credential header exceeds the value-size limit");
+    if (utf8Encoder.encode(headerValue).byteLength > MAX_CREDENTIAL_HEADER_VALUE_BYTES) throw new TypeError("Credential header exceeds the value-size limit");
+    bytes2 += utf8Encoder.encode(`${name}: ${headerValue}\r
+`).byteLength;
+    if (bytes2 > MAX_CREDENTIAL_HEADER_BYTES) throw new TypeError("Credential headers exceed the aggregate size limit");
+    entries.push([name, headerValue]);
+  };
+  if (value instanceof Headers) value.forEach((v, k) => append(k, v));
+  else if (Array.isArray(value)) {
+    if (value.length > MAX_CREDENTIAL_HEADERS) throw new TypeError("Credential headers exceed the header limit");
+    for (const entry of value) append(entry[0], entry[1]);
+  } else {
+    for (const name in value) if (Object.hasOwn(value, name)) append(name, value[name]);
+  }
+  return entries;
+}
+function validateRemoteCredentialHeaders(value) {
+  const headers = new Headers(boundedCredentialEntries(value));
+  const entries = [];
+  headers.forEach((headerValue, name) => entries.push([name, headerValue]));
+  if (entries.length === 0) {
+    throw new TypeError("Authenticated MCP targets require at least one credential header");
+  }
+  if (entries.length > MAX_CREDENTIAL_HEADERS) {
+    throw new TypeError(`Credential headers exceed the ${MAX_CREDENTIAL_HEADERS}-header limit`);
+  }
+  let bytes2 = 0;
+  for (const [name, headerValue] of entries) {
+    if (!headerValue.trim()) throw new TypeError("Credential header values must not be blank");
+    if (FORBIDDEN_CREDENTIAL_HEADERS.has(name)) {
+      throw new TypeError(`Credential header ${name} is not allowed`);
+    }
+    const valueBytes = utf8Encoder.encode(headerValue).byteLength;
+    if (valueBytes > MAX_CREDENTIAL_HEADER_VALUE_BYTES) {
+      throw new TypeError(`Credential header ${name} exceeds the value-size limit`);
+    }
+    bytes2 += utf8Encoder.encode(`${name}: ${headerValue}\r
+`).byteLength;
+  }
+  if (bytes2 > MAX_CREDENTIAL_HEADER_BYTES) {
+    throw new TypeError("Credential headers exceed the aggregate size limit");
+  }
+  return headers;
+}
+
+// src/reports.ts
+import { redactOAuthValue as redactOAuthValue3 } from "@superfunctions/oauth-core";
+
+// src/artifact-guards.ts
+import { McpFnClientError as McpFnClientError2 } from "@mcpfn/client";
+var targetSuiteArtifactGuards = /* @__PURE__ */ new WeakMap();
+var targetSuiteArtifactFinalizer = new FinalizationRegistry((release) => {
+  try {
+    release();
+  } catch {
+  }
+});
+function registerMcpFnTargetSuiteArtifactGuard(report, validate, release, maxBytes) {
+  const previous = targetSuiteArtifactGuards.get(report);
+  if (previous) {
+    targetSuiteArtifactFinalizer.unregister(report);
+    targetSuiteArtifactGuards.delete(report);
+    previous.release();
+  }
+  let active = true;
+  const releaseOnce = () => {
+    if (!active) return;
+    active = false;
+    release();
+  };
+  targetSuiteArtifactGuards.set(report, { maxBytes, validate, release: releaseOnce });
+  targetSuiteArtifactFinalizer.register(report, releaseOnce, report);
+}
+function disposeMcpFnTargetSuiteArtifactGuard(report) {
+  const guard = targetSuiteArtifactGuards.get(report);
+  if (!guard) return;
+  targetSuiteArtifactGuards.delete(report);
+  targetSuiteArtifactFinalizer.unregister(report);
+  guard.release();
+}
+function preserveMcpFnTargetSuiteArtifact(report, artifact) {
+  const guard = targetSuiteArtifactGuards.get(report);
+  if (!guard) {
+    if (report.artifactValidation === "target-aware") {
+      throw new McpFnClientError2(
+        "MCPFN_OPERATION_FAILED",
+        "MCP target artifact proof is unavailable",
+        { phase: "capability-operation" }
+      );
+    }
+    return artifact;
+  }
+  if (new TextEncoder().encode(artifact).byteLength > guard.maxBytes) {
+    throw new Error("Serialized target suite artifact exceeds maxReportBytes");
+  }
+  try {
+    if (!guard.validate(artifact)) throw new Error("unsafe serialized artifact");
+    return artifact;
+  } catch {
+    throw new McpFnClientError2(
+      "MCPFN_OPERATION_FAILED",
+      "MCP artifact structure conflicts with credential redaction",
+      { phase: "capability-operation" }
+    );
+  }
+}
+
+// src/reports.ts
+var MCPFN_TESTING_VERSION = "0.0.5";
+var MCPFN_REPORT_SCHEMA_VERSION = "1.0.0";
+function serializeMcpFnTargetSuiteReport(report, options = {}) {
+  const space = options.space ?? 0;
+  if (!Number.isInteger(space) || space < 0 || space > 10) {
+    throw new TypeError("space must be an integer from 0 through 10");
+  }
+  const serialized = JSON.stringify(report, null, space) + (options.trailingNewline ? "\n" : "");
+  return preserveMcpFnTargetSuiteArtifact(report, serialized);
+}
+function disposeMcpFnTargetSuiteReport(report) {
+  disposeMcpFnTargetSuiteArtifactGuard(report);
+}
+function objectRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function redactedFailureCause(error) {
+  if (!error || typeof error !== "object") return void 0;
+  const cause = error.cause;
+  if (cause === void 0) return void 0;
+  return objectRecord(redactOAuthValue3(cause, {
+    maxDepth: 4,
+    maxArrayEntries: 20,
+    maxObjectEntries: 20,
+    maxStringLength: 1024
+  }));
+}
+function resourceDenied(layer, record, cause) {
+  if (layer === "authorization-server") return false;
+  return [cause?.code, cause?.status, record.code, record.status].some((value) => [401, 403].includes(Number(value)));
+}
+function normalizeMcpFnReportFailure(error, fallbackPhase) {
+  const redacted = redactOAuthValue3(error, {
+    maxDepth: 6,
+    maxArrayEntries: 50,
+    maxObjectEntries: 50,
+    maxStringLength: 2048
+  });
+  const record = objectRecord(redacted) ?? {};
+  const phase = stringField(record.phase) ?? fallbackPhase;
+  const details = objectRecord(record.details);
+  let message = stringField(record.message) ?? String(
+    redactOAuthValue3(error instanceof Error ? error.message : String(error))
+  );
+  const causeRecord = redactedFailureCause(error);
+  const causeMessage = stringField(causeRecord?.message);
+  if (causeMessage && !message.includes(causeMessage)) message = `${message}: ${causeMessage}`;
+  const combinedDetails = causeRecord ? { ...details, cause: causeRecord } : details;
+  const layer = failureLayer(phase);
+  const deniedByResource = resourceDenied(layer, record, causeRecord);
+  return {
+    name: stringField(record.name) ?? "Error",
+    message,
+    layer: deniedByResource ? "resource-server" : layer,
+    ...stringField(record.code) ? { code: stringField(record.code) } : {},
+    ...phase ? { phase } : {},
+    ...combinedDetails ? { details: combinedDetails } : {}
+  };
+}
+function createMcpFnTargetSuiteJUnit(report, options = {}) {
+  const maxBytes = options.maxBytes ?? 1048576;
+  validateArtifactCap(maxBytes);
+  const safe = redactOAuthValue3(report, {
+    maxDepth: 10,
+    maxArrayEntries: 1e3,
+    maxObjectEntries: 200,
+    maxStringLength: 4096
+  });
+  const results = safe.results.filter((result) => result && typeof result === "object" && typeof result.name === "string");
+  const omitted = report.results.length - results.length;
+  const cases = results.map((result) => {
+    const duration = Math.max(0, result.durationMs ?? 0) / 1e3;
+    let failure = "";
+    if (result.status !== "passed") {
+      const failureType = result.status === "failed" ? "scenario" : "incomplete";
+      failure = junitFailure(result.error ?? `Scenario ${result.status}`, failureType);
+    }
+    return `    <testcase name="${xml(result.name)}" classname="mcpfn.scenario" time="${duration.toFixed(3)}">${failure}</testcase>`;
+  });
+  if (safe.failure) {
+    cases.unshift(
+      `    <testcase name="${xml(safe.failure.phase ?? "target")}" classname="mcpfn.${xml(safe.failure.layer)}" time="0.000">${junitFailure(safe.failure.message, safe.failure.code ?? safe.failure.layer)}</testcase>`
+    );
+  }
+  if (safe.status === "incomplete" || omitted > 0 || !safe.ok && !safe.failure && results.every((result) => result.status === "passed")) {
+    cases.push(`    <testcase name="suite-incomplete" classname="mcpfn.report" time="0.000">${junitFailure(safe.incompleteReason ?? "Suite evidence is incomplete or omitted", "incomplete")}</testcase>`);
+  }
+  if (cases.length === 0) {
+    cases.push(
+      '    <testcase name="target-suite" classname="mcpfn.target" time="0.000"></testcase>'
+    );
+  }
+  const failures = cases.filter((entry) => entry.includes("<failure ")).length;
+  let serialized = junitDocument(safe, cases, failures);
+  if (bytes(serialized) <= maxBytes) {
+    return preserveMcpFnTargetSuiteArtifact(report, serialized);
+  }
+  const boundedCases = [
+    `    <testcase name="artifact-cap" classname="mcpfn.report" time="0.000">${junitFailure("JUnit content exceeded maxBytes and was truncated", "incomplete")}</testcase>`
+  ];
+  serialized = junitDocument(safe, boundedCases, 1, true);
+  if (bytes(serialized) > maxBytes) {
+    throw new Error("The minimum McpFn JUnit report exceeds maxBytes");
+  }
+  return preserveMcpFnTargetSuiteArtifact(report, serialized);
+}
+function junitDocument(report, cases, failures, truncated = false) {
+  const suiteName = String(redactOAuthValue3(`mcpfn:${report.target.kind}`));
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    `<testsuite name="${xml(suiteName)}" tests="${cases.length}" failures="${failures}" errors="0" skipped="0">`,
+    "  <properties>",
+    `    <property name="mcpfn.report.schema" value="${xml(MCPFN_REPORT_SCHEMA_VERSION)}"/>`,
+    `    <property name="mcpfn.testing.version" value="${xml(MCPFN_TESTING_VERSION)}"/>`,
+    `    <property name="node.version" value="${xml(report.runtime.node)}"/>`,
+    `    <property name="artifact.truncated" value="${truncated}"/>`,
+    "  </properties>",
+    ...cases,
+    "</testsuite>",
+    ""
+  ].join("\n");
+}
+function junitFailure(message, type) {
+  const safe = String(redactOAuthValue3(message, { maxStringLength: 4096 }));
+  return `<failure type="${xml(type)}" message="${xml(safe)}">${xml(safe)}</failure>`;
+}
+function failureLayer(phase) {
+  if (phase === "resource-discovery" || phase === "transport-connect") {
+    return "resource-server";
+  }
+  if (phase === "authorization-server-discovery" || phase === "client-registration" || phase === "authorization-request" || phase === "authorization-callback" || phase === "token-exchange" || phase === "token-refresh" || phase === "token-revocation") {
+    return "authorization-server";
+  }
+  if (phase === "mcp-initialize" || phase === "capability-operation") {
+    return "mcp-initialization";
+  }
+  if (phase === "scenario") return "scenario";
+  if (phase === "upstream-conformance") return "upstream-conformance";
+  return "mcpfn-preflight";
+}
+function stringField(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return String(value);
+  return void 0;
+}
+function xml(value) {
+  return stripInvalidXmlControls(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function stripInvalidXmlControls(value) {
+  return value.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F\uFFFE\uFFFF\uD800-\uDFFF]/gu, "");
+}
+function validateArtifactCap(maxBytes) {
+  if (!Number.isInteger(maxBytes) || maxBytes < 1024) {
+    throw new Error("maxBytes must be an integer of at least 1024");
+  }
+}
+function bytes(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+
+// src/conformance.ts
 var OFFICIAL_CONFORMANCE_VERSION = "0.1.16";
-async function createAuthenticatedConformanceProxy(options) {
-  const upstream = new URL(options.url);
+function validateAuthenticatedConformanceUrl(url) {
+  const upstream = new URL(url);
   if (!["http:", "https:"].includes(upstream.protocol)) {
     throw new TypeError(
       "Authenticated conformance upstream must use HTTP or HTTPS"
@@ -953,10 +2552,14 @@ async function createAuthenticatedConformanceProxy(options) {
       "Authenticated conformance upstream must use a literal loopback address"
     );
   }
+  return { upstream, hostname };
+}
+async function createAuthenticatedConformanceProxy(options) {
+  const { upstream, hostname } = validateAuthenticatedConformanceUrl(options.url);
   const protocol = upstream.protocol === "https:" ? "https:" : "http:";
   const port = upstream.port === "" ? void 0 : Number(upstream.port);
   const requestPath = `${upstream.pathname}${upstream.search}`;
-  const injected = new Headers(options.headers);
+  const injected = validateRemoteCredentialHeaders(options.headers);
   const activeRequests = /* @__PURE__ */ new Set();
   const activeSockets = /* @__PURE__ */ new Set();
   let proxyAuthority;
@@ -1019,20 +2622,25 @@ async function createAuthenticatedConformanceProxy(options) {
     `http://127.0.0.1:${address.port}`
   );
   proxyAuthority = url.host;
+  let closePromise;
   return {
     url: url.toString(),
-    close: async () => {
-      for (const request of activeRequests) request.destroy();
-      for (const socket of activeSockets) socket.destroy();
-      if (!server.listening) return;
-      await new Promise((resolve, reject) => {
-        server.close((error) => error ? reject(error) : resolve());
-      });
+    close: () => {
+      closePromise ??= (async () => {
+        for (const request of activeRequests) request.destroy();
+        for (const socket of activeSockets) socket.destroy();
+        if (!server.listening) return;
+        await new Promise((resolve, reject) => {
+          server.close((error) => error ? reject(error) : resolve());
+        });
+      })();
+      return closePromise;
     }
   };
 }
 function normalizeLoopbackHostname(hostname) {
-  if (hostname === "127.0.0.1") return "127.0.0.1";
+  const parts = hostname.split(".");
+  if (parts.length === 4 && parts[0] === "127" && parts.every((part) => /^\d{1,3}$/.test(part) && Number(part) <= 255)) return hostname;
   if (hostname === "[::1]") return "::1";
   return void 0;
 }
@@ -1040,9 +2648,9 @@ function npxInvocation(args) {
   if (process.platform !== "win32") return { command: "npx", args };
   const npmExecPath = process.env.npm_execpath;
   const candidates = [
-    npmExecPath ? path.join(path.dirname(npmExecPath), "npx-cli.js") : void 0,
-    path.resolve(path.dirname(process.execPath), "node_modules/npm/bin/npx-cli.js"),
-    path.resolve(path.dirname(process.execPath), "../lib/node_modules/npm/bin/npx-cli.js")
+    npmExecPath ? path2.join(path2.dirname(npmExecPath), "npx-cli.js") : void 0,
+    path2.resolve(path2.dirname(process.execPath), "node_modules/npm/bin/npx-cli.js"),
+    path2.resolve(path2.dirname(process.execPath), "../lib/node_modules/npm/bin/npx-cli.js")
   ].filter((candidate) => Boolean(candidate));
   const npxCli = candidates.find((candidate) => existsSync(candidate));
   if (!npxCli) {
@@ -1068,7 +2676,19 @@ function buildOfficialConformanceArgs(options) {
   if (options.verbose) args.push("--verbose");
   return args;
 }
+function buildOfficialConformanceEnvironment(sensitiveNames = [], source = process.env) {
+  const environment = { ...source };
+  const sensitive = new Set(sensitiveNames.map((name) => name.toLowerCase()));
+  for (const name of Object.keys(environment)) {
+    if (sensitive.has(name.toLowerCase())) delete environment[name];
+  }
+  environment.PATH = [path2.dirname(process.execPath), environment.PATH].filter(Boolean).join(path2.delimiter);
+  return environment;
+}
 async function runOfficialConformance(options) {
+  return runConformance(options, (value) => String(redactOAuthValue4(value, { maxStringLength: 262144 })));
+}
+async function runConformance(options, redactOutput) {
   const nodeMajor = Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10);
   if (nodeMajor < 22) {
     throw new Error(
@@ -1077,40 +2697,170 @@ async function runOfficialConformance(options) {
   }
   const args = buildOfficialConformanceArgs(options);
   const invocation = npxInvocation(args);
-  return await new Promise((resolve, reject) => {
+  const childEnvironment = buildOfficialConformanceEnvironment(
+    options.sensitiveEnvironmentVariables
+  );
+  return await new Promise((resolve) => {
     const child = spawn(invocation.command, invocation.args, {
+      detached: process.platform !== "win32",
       cwd: options.cwd,
-      env: {
-        ...process.env,
-        PATH: [path.dirname(process.execPath), process.env.PATH].filter(Boolean).join(path.delimiter)
-      },
+      env: childEnvironment,
       stdio: options.stdio === "inherit" ? "inherit" : "pipe"
     });
     let stdout = "";
     let stderr = "";
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.once("error", reject);
-    child.once("close", (code) => {
-      resolve({ exitCode: code ?? 1, stdout, stderr });
+    let capturedBytes = 0;
+    let outputExceeded = false;
+    const capture = (chunk, stream) => {
+      if (outputExceeded) return;
+      capturedBytes += Buffer.byteLength(chunk, "utf8");
+      if (capturedBytes > 262144) {
+        outputExceeded = true;
+        stdout = "";
+        stderr = "";
+        void terminateConformanceRunner(child).finally(() => finish(1));
+        return;
+      }
+      if (stream === "stdout") stdout += chunk.toString();
+      else stderr += chunk.toString();
+    };
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => capture(chunk, "stdout"));
+    child.stderr?.on("data", (chunk) => capture(chunk, "stderr"));
+    let settled = false;
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      const failure = normalizeMcpFnReportFailure(error, "upstream-conformance");
+      resolve({
+        formatVersion: 1,
+        kind: "mcpfn.official-conformance-report",
+        ok: false,
+        suiteVersion: OFFICIAL_CONFORMANCE_VERSION,
+        exitCode: 1,
+        stdout: "",
+        stderr: failure.message,
+        failure
+      });
     });
+    const finish = (code) => {
+      if (settled) return;
+      settled = true;
+      let safeStdout = "";
+      let safeStderr = "";
+      let outputFailure = false;
+      try {
+        if (outputExceeded) throw new Error("capture limit");
+        safeStdout = redactOutput(stdout);
+        safeStderr = redactOutput(stderr);
+      } catch {
+        outputFailure = true;
+        safeStdout = "";
+        safeStderr = outputExceeded ? "Conformance output exceeded its capture limit" : "Conformance output omitted because credential redaction exceeded its bounds";
+      }
+      const exitCode = outputFailure ? 1 : code ?? 1;
+      const failure = exitCode === 0 ? void 0 : normalizeMcpFnReportFailure(
+        new Error(safeStderr || safeStdout || `Official conformance exited ${exitCode}`),
+        "upstream-conformance"
+      );
+      resolve({
+        formatVersion: 1,
+        kind: "mcpfn.official-conformance-report",
+        ok: exitCode === 0,
+        suiteVersion: OFFICIAL_CONFORMANCE_VERSION,
+        exitCode,
+        stdout: safeStdout,
+        stderr: safeStderr,
+        ...failure ? { failure } : {}
+      });
+    };
+    child.once("close", finish);
   });
 }
+var retainedConformanceCleanup = /* @__PURE__ */ new WeakMap();
+var McpFnConformanceCleanupError = class extends Error {
+  constructor(release, result) {
+    super("Authenticated conformance credential cleanup failed; retry cleanup");
+    this.result = result;
+    this.name = "McpFnConformanceCleanupError";
+    retainedConformanceCleanup.set(this, release);
+  }
+  result;
+  async retryCleanup() {
+    const release = retainedConformanceCleanup.get(this);
+    if (!release) return;
+    try {
+      await release();
+    } catch {
+      throw this;
+    }
+    retainedConformanceCleanup.delete(this);
+  }
+};
 async function runAuthenticatedOfficialConformance(options) {
-  const { headers, ...conformance } = options;
-  const proxy = await createAuthenticatedConformanceProxy({
-    url: conformance.url,
-    headers
-  });
+  if (options.outputDir !== void 0) throw new TypeError("Authenticated conformance does not support outputDir; serialize the redacted result instead");
+  const { headers, credential, ...conformance } = options;
+  if (headers === void 0 === (credential === void 0)) {
+    throw new TypeError("Provide exactly one of credential or headers for authenticated conformance");
+  }
+  validateAuthenticatedConformanceUrl(conformance.url);
+  const lease = await acquireRemoteCredential(
+    credential ?? { headers },
+    {
+      url: conformance.url,
+      requestId: randomUUID2()
+    }
+  );
+  let proxy;
+  let result;
+  let operationFailure;
+  const safeFailure = (error) => {
+    let message = "Authenticated conformance operation failed";
+    try {
+      message = redactRemoteCredential(lease.credential, error instanceof Error ? error.message : String(error));
+    } catch {
+    }
+    return { error: new Error(message) };
+  };
   try {
-    return await runOfficialConformance({ ...conformance, url: proxy.url });
-  } finally {
-    await proxy.close();
+    proxy = await createAuthenticatedConformanceProxy({
+      url: conformance.url,
+      headers: lease.credential.headers
+    });
+    result = redactRemoteCredential(lease.credential, await runConformance({ ...conformance, stdio: "pipe", url: proxy.url }, (value) => String(redactRemoteCredential(lease.credential, value))), { preserveKeys: true });
+  } catch (error) {
+    operationFailure = safeFailure(error);
+  }
+  try {
+    await proxy?.close();
+  } catch (error) {
+    operationFailure ??= safeFailure(error);
+  }
+  let released = false;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      await lease.release();
+      released = true;
+      break;
+    } catch {
+    }
   }
+  if (!released) {
+    const message = "Authenticated conformance credential cleanup failed; retry cleanup";
+    const cleanupFailure = normalizeMcpFnReportFailure(new Error(message), lease.cleanupPhase());
+    const failedResult = result ? {
+      ...result,
+      ok: false,
+      exitCode: result.exitCode || 1,
+      cleanupFailure,
+      ...result.failure ? {} : { failure: cleanupFailure }
+    } : void 0;
+    throw new McpFnConformanceCleanupError(() => lease.release(), failedResult);
+  }
+  if (operationFailure) throw operationFailure.error;
+  if (!result) throw new Error("Conformance produced no result");
+  return result;
 }
 
 // src/host-profiles.ts
@@ -1197,37 +2947,408 @@ function checkHostCompatibility(manifest, profile) {
       path: `extensions.${extension}`,
       message: `${profile.name} does not support ${extension}`
     });
-  }
-  if (!extensions.has(MCP_APP_EXTENSION_ID)) {
-    for (const tool of manifest.tools) {
-      const ui = tool.metadata?.ui;
-      if (ui?.visibility?.length && !ui.visibility.includes("model")) {
-        issues.push({
-          severity: "incompatible",
-          code: "app-only-tool-unavailable",
-          path: `tools.${tool.name}.metadata.ui.visibility`,
-          message: `${tool.name} is app-only but ${profile.name} does not support MCP Apps`
-        });
-      }
+  }
+  if (!extensions.has(MCP_APP_EXTENSION_ID)) {
+    for (const tool of manifest.tools) {
+      const ui = tool.metadata?.ui;
+      if (ui?.visibility?.length && !ui.visibility.includes("model")) {
+        issues.push({
+          severity: "incompatible",
+          code: "app-only-tool-unavailable",
+          path: `tools.${tool.name}.metadata.ui.visibility`,
+          message: `${tool.name} is app-only but ${profile.name} does not support MCP Apps`
+        });
+      }
+    }
+  }
+  issues.sort((left, right) => {
+    if (left.path !== right.path) return left.path < right.path ? -1 : 1;
+    if (left.code < right.code) return -1;
+    if (left.code > right.code) return 1;
+    return 0;
+  });
+  let status = "compatible";
+  if (issues.some((issue) => issue.severity === "incompatible")) {
+    status = "incompatible";
+  } else if (issues.length > 0) {
+    status = "degraded";
+  }
+  return { status, compatible: status !== "incompatible", issues };
+}
+
+// src/host-authorization.ts
+import {
+  derivePkceS256Challenge as derivePkceS256Challenge2,
+  redactOAuthValue as redactOAuthValue5
+} from "@superfunctions/oauth-core";
+function createHostedAuthorizationFixtures(options) {
+  const issuer = new URL(options.issuer);
+  const resource = new URL(options.resource).toString();
+  const chatgptRedirect = options.chatgptRedirectUri ?? "https://chatgpt.com/connector_platform_oauth_redirect";
+  const claudeRedirect = options.claudeRedirectUri ?? "https://claude.example.com/oauth/callback";
+  const verifier = "mcpfn-role3-shared-pkce-verifier-000000000000000000000000";
+  const registration = (clientId, source, redirectUri, grantTypes) => ({
+    clientId,
+    source,
+    metadata: {
+      client_name: `McpFn ${source} fixture`,
+      redirect_uris: [redirectUri],
+      response_types: ["code"],
+      grant_types: grantTypes,
+      token_endpoint_auth_method: "none"
+    }
+  });
+  const authorization = (clientId, redirectUri) => ({
+    clientId,
+    redirectUri,
+    resource,
+    scopes: ["mcp:read"],
+    state: "mcpfn-role3-state",
+    codeVerifier: verifier
+  });
+  const chatgptId = "chatgpt-client";
+  const claudeId = new URL("/client-metadata/claude", issuer).toString();
+  const dcrId = "dcr-client";
+  const supported = ["authorization_code", "refresh_token"];
+  return [
+    {
+      id: "chatgpt-pre-registered-code-pkce",
+      host: "chatgpt",
+      registration: registration(chatgptId, "pre-registered", chatgptRedirect, supported),
+      authorization: authorization(chatgptId, chatgptRedirect),
+      token: {
+        grantType: "authorization_code",
+        refreshAfterExchange: true
+      },
+      expected: { outcome: "allowed" }
+    },
+    {
+      id: "claude-client-metadata-extensible-grants",
+      host: "claude",
+      registration: registration(claudeId, "client-metadata-document", claudeRedirect, [
+        ...supported,
+        "urn:ietf:params:oauth:grant-type:jwt-bearer",
+        "urn:ietf:params:oauth:grant-type:device_code",
+        "urn:example:params:oauth:grant-type:extension"
+      ]),
+      authorization: authorization(claudeId, claudeRedirect),
+      token: {
+        grantType: "authorization_code",
+        refreshAfterExchange: true
+      },
+      expected: { outcome: "allowed" }
+    },
+    {
+      id: "dynamic-registration-code-pkce",
+      host: "generic",
+      registration: registration(dcrId, "dynamic", "http://127.0.0.1/callback", supported),
+      authorization: authorization(dcrId, "http://127.0.0.1/callback"),
+      token: { grantType: "authorization_code" },
+      expected: { outcome: "allowed" }
+    },
+    {
+      id: "chatgpt-unregistered-redirect",
+      host: "chatgpt",
+      registration: registration(chatgptId, "pre-registered", chatgptRedirect, supported),
+      authorization: authorization(chatgptId, `${chatgptRedirect}/drift`),
+      expected: {
+        outcome: "rejected",
+        errorCode: "invalid_request",
+        phase: "authorization-request"
+      }
+    },
+    {
+      id: "incompatible-registration-grants",
+      host: "generic",
+      registration: registration(
+        "incompatible-client",
+        "pre-registered",
+        "https://client.example.com/callback",
+        ["urn:ietf:params:oauth:grant-type:jwt-bearer"]
+      ),
+      authorization: authorization(
+        "incompatible-client",
+        "https://client.example.com/callback"
+      ),
+      expected: {
+        outcome: "rejected",
+        errorCode: "invalid_client",
+        phase: "authorization-request"
+      }
+    },
+    {
+      id: "actual-unsupported-token-grant",
+      host: "generic",
+      registration: registration(
+        "unsupported-token-client",
+        "pre-registered",
+        "https://client.example.com/callback",
+        supported
+      ),
+      authorization: authorization(
+        "unsupported-token-client",
+        "https://client.example.com/callback"
+      ),
+      token: { grantType: "urn:example:unsupported-token-grant" },
+      expected: {
+        outcome: "rejected",
+        errorCode: "unsupported_grant_type",
+        phase: "token-exchange"
+      }
+    }
+  ];
+}
+async function runHostedAuthorizationRegression(target, fixtures) {
+  const results = [];
+  for (const fixture of fixtures) {
+    results.push(await runHostedCase(target, fixture));
+  }
+  return results;
+}
+async function runHostedCase(target, fixture) {
+  let phase = "client-registration";
+  let responseStatus;
+  try {
+    await target.prepareRegistration(structuredClone(fixture.registration));
+    phase = "authorization-request";
+    const authorization = hostedAuthorizationUrl(target.issuer, fixture);
+    responseStatus = void 0;
+    const authorizationResponse = await target.request(new Request(authorization, {
+      redirect: "manual"
+    }));
+    responseStatus = authorizationResponse.status;
+    const authorizationError = await oauthError2(authorizationResponse);
+    if (authorizationError) {
+      await validateOAuthRejection(authorizationResponse, fixture, target.issuer, "authorization");
+      return assessHostedCase(fixture, phase, authorizationResponse.status, authorizationError);
+    }
+    if (!isRedirect(authorizationResponse.status)) {
+      throw new Error(`Authorization request did not redirect (HTTP ${authorizationResponse.status})`);
+    }
+    const code = validatedRedirectCode(authorizationResponse, fixture, target.issuer);
+    if (fixture.token) return runHostedTokenCase(target, fixture, fixture.token, code);
+    return assessHostedCase(fixture, phase, responseStatus);
+  } catch (error) {
+    return assessHostedFailure(fixture, phase, responseStatus, error);
+  }
+}
+async function runHostedTokenCase(target, fixture, token, code) {
+  let phase = token.grantType === "refresh_token" ? "token-refresh" : "token-exchange";
+  let responseStatus;
+  try {
+    const tokenResponse = await target.request(hostedTokenRequest(
+      target.issuer,
+      tokenRequestBody(fixture, token, code)
+    ));
+    responseStatus = tokenResponse.status;
+    const tokenError = await oauthError2(tokenResponse);
+    if (tokenError) {
+      await validateOAuthRejection(tokenResponse, fixture, target.issuer, "token");
+      return assessHostedCase(fixture, phase, responseStatus, tokenError);
+    }
+    if (!tokenResponse.ok) throw new Error(`Token request returned HTTP ${tokenResponse.status}`);
+    const tokenSet = await validatedTokenSet(tokenResponse);
+    if (!token.refreshAfterExchange) {
+      return assessHostedCase(fixture, phase, responseStatus);
+    }
+    if (typeof tokenSet.refresh_token !== "string" || !tokenSet.refresh_token) {
+      throw new Error("Authorization-code response did not include a refresh token");
+    }
+    phase = "token-refresh";
+    responseStatus = void 0;
+    const refreshBody = new URLSearchParams({
+      grant_type: "refresh_token",
+      client_id: fixture.authorization.clientId,
+      refresh_token: tokenSet.refresh_token,
+      resource: fixture.authorization.resource
+    });
+    const refreshResponse = await target.request(hostedTokenRequest(target.issuer, refreshBody));
+    responseStatus = refreshResponse.status;
+    const refreshError = await oauthError2(refreshResponse);
+    if (refreshError) {
+      await validateOAuthRejection(refreshResponse, fixture, target.issuer, "token");
+      return assessHostedCase(fixture, phase, responseStatus, refreshError);
+    }
+    if (!refreshResponse.ok) {
+      throw new Error(`Refresh request returned HTTP ${refreshResponse.status}`);
     }
+    await validatedTokenSet(refreshResponse);
+    return assessHostedCase(fixture, phase, responseStatus);
+  } catch (error) {
+    return assessHostedFailure(fixture, phase, responseStatus, error);
   }
-  issues.sort((left, right) => {
-    if (left.path !== right.path) return left.path < right.path ? -1 : 1;
-    if (left.code < right.code) return -1;
-    if (left.code > right.code) return 1;
-    return 0;
+}
+function tokenRequestBody(fixture, token, code) {
+  const body = new URLSearchParams({
+    grant_type: token.grantType,
+    client_id: fixture.authorization.clientId
   });
-  let status = "compatible";
-  if (issues.some((issue) => issue.severity === "incompatible")) {
-    status = "incompatible";
-  } else if (issues.length > 0) {
-    status = "degraded";
+  if (token.grantType === "authorization_code") {
+    body.set("code", token.code ?? code);
+    body.set("redirect_uri", fixture.authorization.redirectUri);
+    body.set("code_verifier", fixture.authorization.codeVerifier);
+    body.set("resource", fixture.authorization.resource);
+  } else if (token.refreshToken) {
+    body.set("refresh_token", token.refreshToken);
+    body.set("resource", fixture.authorization.resource);
+  }
+  return body;
+}
+function hostedTokenRequest(issuer, body) {
+  return new Request(new URL("token", ensureTrailingSlash(issuer)), {
+    method: "POST",
+    redirect: "manual",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body
+  });
+}
+function assessHostedFailure(fixture, phase, responseStatus, error) {
+  const redacted = redactOAuthValue5(error);
+  const safe = redacted && typeof redacted === "object" ? redacted : {};
+  const code = typeof safe.code === "string" ? safe.code : void 0;
+  const message = typeof safe.message === "string" ? safe.message : String(redacted);
+  return assessHostedCase(
+    fixture,
+    phase,
+    responseStatus,
+    code,
+    message || "Hosted adapter failed"
+  );
+}
+function hostedAuthorizationUrl(issuer, fixture) {
+  const authorization = new URL("authorize", ensureTrailingSlash(issuer));
+  authorization.searchParams.set("response_type", "code");
+  authorization.searchParams.set("client_id", fixture.authorization.clientId);
+  authorization.searchParams.set("redirect_uri", fixture.authorization.redirectUri);
+  authorization.searchParams.set(
+    "code_challenge",
+    derivePkceS256Challenge2(fixture.authorization.codeVerifier)
+  );
+  authorization.searchParams.set("code_challenge_method", "S256");
+  authorization.searchParams.set("state", fixture.authorization.state);
+  authorization.searchParams.set("resource", fixture.authorization.resource);
+  authorization.searchParams.set("scope", fixture.authorization.scopes.join(" "));
+  return authorization;
+}
+function assessHostedCase(fixture, phase, responseStatus, errorCode, error) {
+  const observedOutcome = errorCode || error ? "rejected" : "allowed";
+  const expected = fixture.expected;
+  const passed = !error && observedOutcome === expected.outcome && (expected.errorCode === void 0 || expected.errorCode === errorCode) && (expected.phase === void 0 || expected.phase === phase);
+  const expectedCode = expected.errorCode ? `:${expected.errorCode}` : "";
+  const observedCode = errorCode ? `:${errorCode}` : "";
+  const mismatch = `Expected ${expected.outcome}${expectedCode}, received ${observedOutcome}${observedCode}`;
+  return {
+    formatVersion: 1,
+    id: fixture.id,
+    host: fixture.host,
+    status: passed ? "passed" : "failed",
+    phase,
+    layer: phase === "client-registration" ? "mcpfn-preflight" : "authorization-server",
+    ...responseStatus === void 0 ? {} : { responseStatus },
+    ...errorCode ? { errorCode } : {},
+    ...!passed || error ? {
+      error: error ?? mismatch
+    } : {}
+  };
+}
+function isJsonResponse(response) {
+  const mediaType = (response.headers.get("content-type") ?? "").split(";", 1)[0].trim().toLowerCase();
+  return mediaType === "application/json" || /^application\/[a-z0-9!#$&^_.+-]+\+json$/.test(mediaType);
+}
+async function oauthError2(response) {
+  const location = response.headers.get("location");
+  if (location) {
+    const code = new URL(location).searchParams.get("error");
+    if (code) return code;
+  }
+  if (!isJsonResponse(response)) return void 0;
+  const body = await response.clone().json().catch(() => void 0);
+  return typeof body?.error === "string" ? body.error : void 0;
+}
+async function validateOAuthRejection(response, fixture, issuer, context) {
+  if (context === "authorization" && isRedirect(response.status)) {
+    validateAuthorizationErrorRedirect(response, fixture, issuer);
+    return;
   }
-  return { status, compatible: status !== "incompatible", issues };
+  const body = await response.clone().json().catch(() => void 0);
+  const registered = fixture.registration.metadata.redirect_uris?.includes(fixture.authorization.redirectUri);
+  if (context === "authorization" && body?.error !== "invalid_client" && registered) {
+    throw new Error("Registered authorization requests require an OAuth error callback");
+  }
+  if (response.status !== 400) throw new Error("OAuth error response has invalid HTTP status");
+  if (response.headers.has("location") || !isJsonResponse(response) || !body || typeof body.error !== "string" || !body.error) {
+    throw new Error("OAuth error response must be a JSON error envelope");
+  }
+}
+function validateAuthorizationErrorRedirect(response, fixture, issuer) {
+  const callback = new URL(response.headers.get("location") ?? "");
+  const registered = fixture.registration.metadata.redirect_uris;
+  if (!registered?.includes(fixture.authorization.redirectUri)) {
+    throw new Error("Rejected redirect URI must not receive a callback");
+  }
+  const errors = callback.searchParams.getAll("error");
+  if (errors.length !== 1 || !errors[0] || callback.searchParams.has("code")) {
+    throw new Error("Invalid OAuth error callback");
+  }
+  if (errors[0] === "invalid_client") {
+    throw new Error("Invalid-client authorization failures must not redirect");
+  }
+  callback.searchParams.delete("error");
+  callback.searchParams.delete("error_description");
+  callback.searchParams.delete("error_uri");
+  callback.searchParams.set("code", "error-envelope-validation");
+  validatedRedirectCode(
+    new Response(null, { status: response.status, headers: { location: callback.toString() } }),
+    fixture,
+    issuer
+  );
+}
+function validatedRedirectCode(response, fixture, issuer) {
+  const location = response.headers.get("location");
+  if (!location) throw new Error("Authorization callback is missing");
+  const callback = new URL(location);
+  const expected = new URL(fixture.authorization.redirectUri);
+  const codes = callback.searchParams.getAll("code");
+  const states = callback.searchParams.getAll("state");
+  if (codes.length !== 1 || !codes[0] || states.length !== 1 || states[0] !== fixture.authorization.state) {
+    throw new Error("Authorization callback code or state is invalid");
+  }
+  const issuers = callback.searchParams.getAll("iss");
+  if (issuers.length > 1 || issuers.length === 1 && issuers[0] !== issuer) {
+    throw new Error("Authorization callback issuer is invalid");
+  }
+  if (callback.protocol !== expected.protocol || callback.host !== expected.host || callback.username !== expected.username || callback.password !== expected.password || callback.pathname !== expected.pathname || callback.hash !== expected.hash || [...new Set(expected.searchParams.keys())].some((key) => JSON.stringify(callback.searchParams.getAll(key)) !== JSON.stringify(expected.searchParams.getAll(key)))) {
+    throw new Error("Authorization callback destination is invalid");
+  }
+  return codes[0];
+}
+async function validatedTokenSet(response) {
+  if (response.status !== 200) throw new Error("Successful token responses must use HTTP 200");
+  if (!isJsonResponse(response)) throw new Error("Token response must use a JSON media type");
+  if (!hasHeaderDirective(response.headers.get("cache-control"), "no-store") || !hasHeaderDirective(response.headers.get("pragma"), "no-cache")) {
+    throw new Error("Token responses must disable caching with Cache-Control: no-store and Pragma: no-cache");
+  }
+  const value = await response.clone().json();
+  if (!value || typeof value.access_token !== "string" || !/^[\dA-Za-z._~+/-]+=*$/.test(value.access_token) || typeof value.token_type !== "string" || value.token_type.toLowerCase() !== "bearer") {
+    throw new Error("Token response requires an access token and Bearer token type");
+  }
+  return value;
+}
+function hasHeaderDirective(value, expected) {
+  return (value ?? "").split(",").some(
+    (directive) => directive.trim().toLowerCase() === expected
+  );
+}
+function isRedirect(status) {
+  return [301, 302, 303, 307, 308].includes(status);
+}
+function ensureTrailingSlash(value) {
+  const url = new URL(value);
+  if (!url.pathname.endsWith("/")) url.pathname += "/";
+  return url;
 }
 
 // src/scenarios.ts
-import { redactOAuthValue } from "@superfunctions/oauth-core";
 function createMcpFnScenario(name, operation, result) {
   switch (operation.kind) {
     case "tools.call":
@@ -1456,16 +3577,31 @@ async function runScenarios(client, scenarios, options = {}) {
   const observedEvents = [];
   const maxObservedEvents = options.maxObservedEvents ?? 500;
   let droppedObservedEvents = 0;
+  let redactionOmittedObservedEvents = 0;
+  let observedRedactionOmissionEvents = 0;
   let attributedDroppedObservedEvents = 0;
+  let attributedRedactionOmittedObservedEvents = 0;
+  const initialClientEventRedactionOmissions = client.session.getRedactionOmissionCounts().clientEvents;
   const pushResult = (result) => {
     const newlyDropped = droppedObservedEvents - attributedDroppedObservedEvents;
+    const newlyRedactionOmitted = redactionOmittedObservedEvents - attributedRedactionOmittedObservedEvents;
     results.push({
       ...result,
-      ...newlyDropped > 0 ? { droppedObservedEvents: (result.droppedObservedEvents ?? 0) + newlyDropped } : {}
+      ...newlyDropped > 0 ? { droppedObservedEvents: (result.droppedObservedEvents ?? 0) + newlyDropped } : {},
+      ...newlyRedactionOmitted > 0 ? {
+        redactionOmittedObservedEvents: (result.redactionOmittedObservedEvents ?? 0) + newlyRedactionOmitted
+      } : {}
     });
     attributedDroppedObservedEvents = droppedObservedEvents;
+    attributedRedactionOmittedObservedEvents = redactionOmittedObservedEvents;
   };
   const unsubscribe = client.session.onEvent((event) => {
+    if (client.session.isRedactionOmission(event)) {
+      observedRedactionOmissionEvents += 1;
+      droppedObservedEvents += 1;
+      redactionOmittedObservedEvents += 1;
+      return;
+    }
     observedEvents.push(event);
     if (observedEvents.length > maxObservedEvents) {
       observedEvents.shift();
@@ -1489,7 +3625,7 @@ async function runScenarios(client, scenarios, options = {}) {
           ...common,
           status: "incomplete",
           durationMs: 0,
-          error: truncateError(`Skipped after timed-out scenario: ${timedOutScenario}`, options)
+          error: truncateError(`Skipped after timed-out scenario: ${timedOutScenario}`, options, client)
         });
         continue;
       }
@@ -1501,7 +3637,8 @@ async function runScenarios(client, scenarios, options = {}) {
           durationMs: 0,
           error: truncateError(
             `Missing scenario variables: ${resolved.missing.join(", ")}`,
-            options
+            options,
+            client
           )
         });
         continue;
@@ -1511,7 +3648,7 @@ async function runScenarios(client, scenarios, options = {}) {
           ...common,
           status: "incomplete",
           durationMs: 0,
-          error: truncateError(scenario.incompleteReason ?? "Scenario is incomplete", options)
+          error: truncateError(scenario.incompleteReason ?? "Scenario is incomplete", options, client)
         });
         continue;
       }
@@ -1543,7 +3680,7 @@ async function runScenarios(client, scenarios, options = {}) {
           ...common,
           status: "failed",
           durationMs: performance.now() - startedAt,
-          error: truncateError(error instanceof Error ? error.message : String(error), options)
+          error: truncateError(error instanceof Error ? error.message : String(error), options, client)
         });
         if (timedOut) timedOutScenario = scenario.name;
       } finally {
@@ -1551,11 +3688,21 @@ async function runScenarios(client, scenarios, options = {}) {
       }
     }
   } finally {
+    const unobservedRedactionOmissions = Math.max(
+      0,
+      client.session.getRedactionOmissionCounts().clientEvents - initialClientEventRedactionOmissions - observedRedactionOmissionEvents
+    );
+    droppedObservedEvents += unobservedRedactionOmissions;
+    redactionOmittedObservedEvents += unobservedRedactionOmissions;
     const unattributed = droppedObservedEvents - attributedDroppedObservedEvents;
     const lastResult = results.at(-1);
     if (lastResult && unattributed > 0) {
       lastResult.droppedObservedEvents = (lastResult.droppedObservedEvents ?? 0) + unattributed;
     }
+    const unattributedRedaction = redactionOmittedObservedEvents - attributedRedactionOmittedObservedEvents;
+    if (lastResult && unattributedRedaction > 0) {
+      lastResult.redactionOmittedObservedEvents = (lastResult.redactionOmittedObservedEvents ?? 0) + unattributedRedaction;
+    }
     unsubscribe();
   }
   return results;
@@ -1565,20 +3712,29 @@ function resolveScenarioVariables(scenario, supplied) {
   const required = new Set(scenario.variables ?? []);
   const marker = /\$\{([A-Z][A-Z0-9_]*)\}/g;
   const encodedMarker = /%24%7[Bb]([A-Z][A-Z0-9_]*)%7[Dd]/g;
+  const visitString = (value) => {
+    for (const match of value.matchAll(marker)) required.add(match[1]);
+    for (const match of value.matchAll(encodedMarker)) required.add(match[1]);
+    return value.replace(marker, (original, name) => values[name] ?? original).replace(
+      encodedMarker,
+      (original, name) => values[name] === void 0 ? original : encodeURIComponent(values[name])
+    );
+  };
   const visit = (value) => {
-    if (typeof value === "string") {
-      for (const match of value.matchAll(marker)) required.add(match[1]);
-      for (const match of value.matchAll(encodedMarker)) required.add(match[1]);
-      return value.replace(marker, (original, name) => values[name] ?? original).replace(
-        encodedMarker,
-        (original, name) => values[name] === void 0 ? original : encodeURIComponent(values[name])
-      );
-    }
+    if (typeof value === "string") return visitString(value);
     if (Array.isArray(value)) return value.map(visit);
     if (value && typeof value === "object") {
-      return Object.fromEntries(
-        Object.entries(value).map(([key, entry]) => [key, visit(entry)])
-      );
+      const entries = [];
+      const keys = /* @__PURE__ */ new Set();
+      for (const [key, entry] of Object.entries(value)) {
+        const resolvedKey = visitString(key);
+        if (keys.has(resolvedKey)) {
+          throw new Error("Scenario variable substitution creates duplicate object key");
+        }
+        keys.add(resolvedKey);
+        entries.push([resolvedKey, visit(entry)]);
+      }
+      return Object.fromEntries(entries);
     }
     return value;
   };
@@ -1595,6 +3751,11 @@ function createMcpFnScenarioReport(results, options = {}) {
     (total, result) => total + (result.droppedObservedEvents ?? 0),
     0
   );
+  const redactionOmittedObservedEvents = results.reduce(
+    (total, result) => total + (result.redactionOmittedObservedEvents ?? 0),
+    0
+  );
+  const overflowedObservedEvents = droppedObservedEvents - redactionOmittedObservedEvents;
   const report = {
     formatVersion: 1,
     kind: "mcpfn.scenario-report",
@@ -1606,7 +3767,13 @@ function createMcpFnScenarioReport(results, options = {}) {
     incomplete,
     droppedResults: 0,
     droppedObservedEvents,
-    ...droppedObservedEvents > 0 ? { incompleteReason: "Observed client events exceeded maxObservedEvents" } : {},
+    ...redactionOmittedObservedEvents > 0 ? { redactionOmittedObservedEvents } : {},
+    ...droppedObservedEvents > 0 ? {
+      incompleteReason: [
+        ...redactionOmittedObservedEvents > 0 ? ["Observed client events were omitted because credential redaction failed"] : [],
+        ...overflowedObservedEvents > 0 ? ["Observed client events exceeded maxObservedEvents"] : []
+      ].join("; ")
+    } : {},
     results: structuredClone(results)
   };
   const maxBytes = options.maxBytes ?? 1048576;
@@ -1747,12 +3914,16 @@ async function executeAuthScenario(scenario, signal, runOptions) {
   }
   assertExpected(await runOptions.auth(scenario, signal), scenario.expect);
 }
-function truncateError(value, options) {
-  const redacted = String(redactOAuthValue(value));
+function truncateError(value, options, client) {
+  let redacted = "Scenario error omitted because credential redaction failed";
+  try {
+    redacted = String(client.session.redact(value));
+  } catch {
+  }
   const maxBytes = options.maxErrorBytes ?? 4096;
-  const bytes = new TextEncoder().encode(redacted);
-  if (bytes.byteLength <= maxBytes) return redacted;
-  return `${new TextDecoder().decode(bytes.slice(0, Math.max(0, maxBytes - 16)))}...[TRUNCATED]`;
+  const bytes2 = new TextEncoder().encode(redacted);
+  if (bytes2.byteLength <= maxBytes) return redacted;
+  return `${new TextDecoder().decode(bytes2.slice(0, Math.max(0, maxBytes - 16)))}...[TRUNCATED]`;
 }
 function defaultSideEffect(operation) {
   if (operation === "tools.call" || operation === "tools.call:task") {
@@ -1816,87 +3987,721 @@ async function listScenarioInventory(client, kind, requestOptions) {
 }
 
 // src/suite.ts
-import { redactOAuthValue as redactOAuthValue2 } from "@superfunctions/oauth-core";
-async function runMcpFnTargetSuite(options) {
-  const timeline = [];
-  let droppedTimelineEvents = 0;
-  const maxTimelineEvents = options.maxTimelineEvents ?? 500;
-  if (!Number.isInteger(maxTimelineEvents) || maxTimelineEvents < 1) {
-    throw new Error("maxTimelineEvents must be a positive integer");
+import {
+  McpFnClientError as McpFnClientError3
+} from "@mcpfn/client";
+var suiteCleanupOwners = /* @__PURE__ */ new WeakMap();
+function retryTargetSuiteCleanup(error) {
+  const owner = suiteCleanupOwners.get(error);
+  if (!owner) return Promise.resolve();
+  if (owner.pending) return owner.pending;
+  const pending = Promise.resolve().then(owner.close).then(
+    () => {
+      suiteCleanupOwners.delete(error);
+    },
+    () => {
+      throw error;
+    }
+  ).finally(() => {
+    owner.pending = void 0;
+  });
+  owner.pending = pending;
+  return pending;
+}
+var McpFnTargetSuiteCleanupError = class extends Error {
+  constructor(report, close) {
+    super("Target suite cleanup failed; retain this error and retryCleanup()");
+    this.report = report;
+    this.name = "McpFnTargetSuiteCleanupError";
+    suiteCleanupOwners.set(this, { close });
   }
-  const maxReportBytes = options.maxReportBytes ?? 1048576;
-  validateReportCap(maxReportBytes);
-  const consumerDiagnostic = options.client?.diagnostics;
-  const client = await McpFnTestClient.connectTarget(
-    options.target,
-    options.clientInfo ?? { name: "mcpfn-suite", version: "0.0.1" },
-    {
-      ...options.client,
-      diagnostics: async (event) => {
-        timeline.push(redactOAuthValue2(event));
-        if (timeline.length > maxTimelineEvents) {
-          timeline.shift();
-          droppedTimelineEvents += 1;
+  report;
+  retryCleanup() {
+    return retryTargetSuiteCleanup(this);
+  }
+};
+var McpFnTargetSuiteArtifactCleanupError = class extends Error {
+  constructor(close, cause) {
+    super(`${cause.message}; retain this error and retryCleanup()`, { cause });
+    this.name = "McpFnTargetSuiteArtifactCleanupError";
+    suiteCleanupOwners.set(this, { close });
+  }
+  retryCleanup() {
+    return retryTargetSuiteCleanup(this);
+  }
+};
+async function runMcpFnTargetSuite(options) {
+  const artifactRedaction = beginSuiteArtifactRedaction(options.target);
+  let finishRedaction = artifactRedaction.finish;
+  const retainArtifactGuard = (report) => {
+    registerMcpFnTargetSuiteArtifactGuard(
+      report,
+      (artifact) => {
+        if (!artifactRedaction.retained) return false;
+        if (options.target.assertArtifactSafe) {
+          options.target.assertArtifactSafe(artifact);
+          return true;
         }
-        await consumerDiagnostic?.(event);
+        if (!options.target.redact) return true;
+        return Object.is(
+          redactSuiteArtifact(options.target, artifact, { preserveKeys: false }),
+          artifact
+        );
+      },
+      finishRedaction,
+      options.maxReportBytes ?? 1048576
+    );
+    finishRedaction = () => void 0;
+    try {
+      preserveMcpFnTargetSuiteArtifact(report, JSON.stringify(report));
+    } catch (error) {
+      disposeMcpFnTargetSuiteArtifactGuard(report);
+      throw error;
+    }
+  };
+  try {
+    const report = await runTargetSuite(options);
+    retainArtifactGuard(report);
+    return report;
+  } catch (error) {
+    if (error instanceof McpFnTargetSuiteCleanupError) {
+      try {
+        retainArtifactGuard(error.report);
+      } catch (artifactError) {
+        const cause = artifactError instanceof Error ? artifactError : new Error("Target report artifact proof failed");
+        throw new McpFnTargetSuiteArtifactCleanupError(
+          () => error.retryCleanup(),
+          cause
+        );
       }
     }
-  );
-  const execution = await (async () => {
+    throw error;
+  } finally {
+    finishRedaction();
+  }
+}
+function beginSuiteArtifactRedaction(target) {
+  let finish;
+  if (target.beginRedactionScope) {
     try {
-      if (options.manifest) {
-        await assertManifestContract(client, options.manifest, {
-          expectedToolNames: options.expectedToolNames
-        });
+      finish = target.beginRedactionScope();
+    } catch {
+      return { finish: () => void 0, retained: false };
+    }
+    if (!finish) return { finish: () => void 0, retained: false };
+  } else {
+    finish = beginTargetCredentialRedaction(target);
+  }
+  return {
+    finish: () => {
+      try {
+        finish?.();
+      } catch {
       }
-      const results2 = await runScenarios(client, options.scenarios ?? [], options.scenarioRun);
+    },
+    retained: true
+  };
+}
+function redactSuiteArtifact(target, value, options = {}) {
+  const scrubbed = target.redact ? target.redact(value, options) : value;
+  return redactTargetCredentials(target, scrubbed, options);
+}
+function compareInventoryNames(left, right) {
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+function reportProjectionFailureReason(error, projectionFailure) {
+  if (error instanceof McpFnRedactionLimitError) {
+    return "Credential redaction exceeded its traversal budget";
+  }
+  if (projectionFailure === "redaction") {
+    return "Credential redaction failed; report content omitted because safe serialization failed";
+  }
+  return "Report content omitted because safe serialization failed";
+}
+var SuiteDiagnosticCollector = class {
+  constructor(maxEvents, maxBytes, target, consumer) {
+    this.maxEvents = maxEvents;
+    this.maxBytes = maxBytes;
+    this.target = target;
+    this.consumer = consumer;
+  }
+  maxEvents;
+  maxBytes;
+  target;
+  consumer;
+  timeline = [];
+  timelineSizes = [];
+  timelineBytes = 0;
+  observedRedactionOmissions = 0;
+  initialRedactionOmissions = 0;
+  dropped = 0;
+  countExceeded = false;
+  bytesExceeded = false;
+  serializationFailed = false;
+  redactionFailed = false;
+  cleanupFailure;
+  captureBaseline(client) {
+    this.initialRedactionOmissions = client.session.getRedactionOmissionCounts().diagnostics;
+  }
+  captureUnobserved(client) {
+    const total = client?.session.getRedactionOmissionCounts().diagnostics ?? this.initialRedactionOmissions;
+    const unobserved = Math.max(
+      0,
+      total - this.initialRedactionOmissions - this.observedRedactionOmissions
+    );
+    if (unobserved > 0) {
+      this.redactionFailed = true;
+      this.dropped += unobserved;
+    }
+  }
+  async record(client, event) {
+    if (client?.session.isRedactionOmission(event)) {
+      this.observedRedactionOmissions += 1;
+      this.redactionFailed = true;
+      this.dropped += 1;
+    }
+    if (["token-revocation", "transport-close"].includes(event.phase) && event.outcome === "failed") {
+      this.cleanupFailure ??= normalizeMcpFnReportFailure({
+        name: "CleanupError",
+        message: "Target cleanup failed",
+        code: event.code,
+        phase: event.phase
+      });
+    }
+    const safeEvent = redactTargetCredentials(this.target, event, { preserveKeys: true });
+    const bytes2 = this.serializedBytes(safeEvent);
+    if (bytes2 === void 0) {
+      await this.consumer?.(safeEvent);
+      return;
+    }
+    if (bytes2 > this.maxBytes) {
+      this.bytesExceeded = true;
+      this.dropped += 1;
+    } else {
+      this.timeline.push(safeEvent);
+      this.timelineSizes.push(bytes2);
+      this.timelineBytes += bytes2;
+      this.enforceBounds();
+    }
+    await this.consumer?.(safeEvent);
+  }
+  serializedBytes(event) {
+    try {
+      const json2 = JSON.stringify(event, (_key, value) => {
+        if (value === void 0 || typeof value === "number" && !Number.isFinite(value)) {
+          throw new Error("Diagnostic contains a non-JSON value");
+        }
+        return value;
+      });
+      structuredClone(event);
+      return Buffer.byteLength(json2);
+    } catch {
+      this.serializationFailed = true;
+      this.dropped += 1;
+      return void 0;
+    }
+  }
+  enforceBounds() {
+    while (this.timeline.length > this.maxEvents || this.timelineBytes > this.maxBytes) {
+      this.countExceeded ||= this.timeline.length > this.maxEvents;
+      this.bytesExceeded ||= this.timelineBytes > this.maxBytes;
+      this.timeline.shift();
+      this.timelineBytes -= this.timelineSizes.shift();
+      this.dropped += 1;
+    }
+  }
+};
+async function executeConnectedSuite(client, options) {
+  let manifestChecked = false;
+  if (options.manifest) {
+    manifestChecked = true;
+    await assertManifestContract(client, options.manifest, {
+      expectedToolNames: options.expectedToolNames
+    });
+  } else if (options.expectedToolNames) {
+    const actual = (await client.listTools()).map((tool) => tool.name).sort(compareInventoryNames);
+    const expected = [...options.expectedToolNames].sort(compareInventoryNames);
+    if (stableJson(actual) !== stableJson(expected)) {
+      throw new McpFnAssertionError(
+        `Tool inventory mismatch: expected ${stableJson(expected)}, actual ${stableJson(actual)}`
+      );
+    }
+  }
+  const results = await runScenarios(client, options.scenarios ?? [], options.scenarioRun);
+  return {
+    manifestChecked,
+    execution: {
+      results,
+      server: client.session.getServerVersion(),
+      capabilities: client.session.getServerCapabilities()
+    }
+  };
+}
+function safeTargetFailure(target, error) {
+  try {
+    return normalizeMcpFnReportFailure(redactSuiteArtifact(target, error, { preserveKeys: true }));
+  } catch {
+    return normalizeMcpFnReportFailure({
+      name: "RedactionError",
+      code: "MCPFN_REDACTION_FAILED",
+      message: "Target failure omitted because credential redaction failed"
+    });
+  }
+}
+function initialTargetDescriptor(target) {
+  const kind = target.kind;
+  return ["stdio", "streamable-http", "authenticated-streamable-http", "in-memory", "custom"].includes(kind) ? { kind } : { kind: "custom" };
+}
+function safeInitialTargetDescriptor(target) {
+  try {
+    return initialTargetDescriptor(target);
+  } catch {
+    return { kind: "custom" };
+  }
+}
+function projectSuiteArtifacts(options, client, execution) {
+  const fallback = {
+    target: safeInitialTargetDescriptor(options.target),
+    execution
+  };
+  try {
+    if (client?.session.state !== "connected") {
+      return execution.results.length || execution.server || execution.capabilities ? { ...fallback, failure: "serialization" } : fallback;
+    }
+    let described;
+    try {
+      described = options.target.describe();
+    } catch {
+      return { ...fallback, failure: "serialization" };
+    }
+    try {
+      const { kind, ...descriptor } = described;
       return {
-        results: results2,
-        server: client.session.getServerVersion(),
-        capabilities: client.session.getServerCapabilities()
+        target: {
+          ...redactSuiteArtifact(options.target, descriptor, { preserveKeys: false }),
+          kind: client.session.preserveArtifactStructure(kind)
+        },
+        manifestHash: options.manifest ? redactSuiteArtifact(options.target, options.manifest.hash, { preserveKeys: false }) : void 0,
+        execution: {
+          server: execution.server === void 0 ? void 0 : redactSuiteArtifact(options.target, execution.server, { preserveKeys: false }),
+          capabilities: execution.capabilities === void 0 ? void 0 : redactSuiteArtifact(options.target, execution.capabilities, { preserveKeys: false }),
+          results: execution.results.map((result) => ({
+            ...result,
+            name: redactSuiteArtifact(options.target, result.name, { preserveKeys: false }),
+            operation: redactSuiteArtifact(options.target, result.operation, { preserveKeys: false }),
+            ...result.tool === void 0 ? {} : {
+              tool: redactSuiteArtifact(options.target, result.tool, { preserveKeys: false })
+            }
+          }))
+        }
       };
-    } finally {
-      await client.close();
+    } catch {
+      return { ...fallback, failure: "redaction" };
+    }
+  } catch {
+    return { ...fallback, failure: "serialization" };
+  }
+}
+var suiteStructureKeys = [
+  "formatVersion",
+  "kind",
+  "artifactValidation",
+  "status",
+  "runtime",
+  "ok",
+  "target",
+  "server",
+  "capabilities",
+  "manifestChecked",
+  "manifestHash",
+  "total",
+  "passed",
+  "failed",
+  "incomplete",
+  "droppedResults",
+  "droppedObservedEvents",
+  "redactionOmittedObservedEvents",
+  "incompleteReason",
+  "failure",
+  "timeline",
+  "droppedTimelineEvents",
+  "results",
+  "node",
+  "scenarioFormatVersion",
+  "reportSchemaVersion",
+  "packages",
+  "testing",
+  "name",
+  "message",
+  "layer",
+  "code",
+  "phase",
+  "details",
+  "outcome",
+  "requestId",
+  "at",
+  "sideEffect",
+  "durationMs",
+  "error",
+  "operation",
+  "tool"
+];
+var suiteStructureValues = [
+  "mcpfn.target-suite-report",
+  "target-aware",
+  "complete",
+  "incomplete",
+  "passed",
+  "failed",
+  "started",
+  "succeeded",
+  "none",
+  "idempotent",
+  "non-idempotent",
+  "mcpfn-preflight",
+  "authorization-server",
+  "resource-server",
+  "mcp-initialization",
+  "scenario",
+  "upstream-conformance",
+  "resource-discovery",
+  "authorization-server-discovery",
+  "client-registration",
+  "authorization-request",
+  "authorization-callback",
+  "token-exchange",
+  "token-refresh",
+  "token-revocation",
+  "transport-connect",
+  "mcp-initialize",
+  "capability-operation",
+  "transport-close",
+  "authenticated-streamable-http",
+  "streamable-http",
+  "stdio",
+  "in-memory",
+  "custom"
+];
+function captureSuiteStructureGuard(target, projection, diagnostics, failure) {
+  const candidates = /* @__PURE__ */ new Set([
+    ...suiteStructureKeys,
+    ...suiteStructureValues,
+    process.version,
+    MCPFN_REPORT_SCHEMA_VERSION,
+    MCPFN_TESTING_VERSION,
+    projection.target.kind
+  ]);
+  if (failure?.phase) candidates.add(failure.phase);
+  for (const result of projection.execution.results) {
+    candidates.add(result.status);
+    if (result.sideEffect) candidates.add(result.sideEffect);
+  }
+  for (const event of diagnostics.timeline) {
+    candidates.add(event.phase);
+    candidates.add(event.outcome);
+    if (event.target?.kind) candidates.add(event.target.kind);
+  }
+  const safe = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    try {
+      if (redactSuiteArtifact(target, candidate, { preserveKeys: false }) === candidate) {
+        safe.add(candidate);
+      }
+    } catch {
+    }
+  }
+  return {
+    assert(value) {
+      if (!safe.has(value)) throw new McpFnStructuralCredentialCollisionError();
+    }
+  };
+}
+function assertStructureKeys(value, guard) {
+  for (const key of Object.keys(value)) guard.assert(key);
+}
+function assertTargetStructure(target, guard) {
+  guard.assert("kind");
+  guard.assert(target.kind);
+}
+function assertSuiteReportStructure(report, guard) {
+  assertStructureKeys(report, guard);
+  guard.assert(report.kind);
+  if (report.artifactValidation) guard.assert(report.artifactValidation);
+  guard.assert(report.status);
+  assertStructureKeys(report.runtime, guard);
+  guard.assert(report.runtime.node);
+  guard.assert(report.runtime.reportSchemaVersion);
+  assertStructureKeys(report.runtime.packages, guard);
+  guard.assert(report.runtime.packages.testing);
+  assertTargetStructure(report.target, guard);
+  if (report.failure) {
+    assertStructureKeys(report.failure, guard);
+    guard.assert(report.failure.layer);
+    if (report.failure.phase) guard.assert(report.failure.phase);
+  }
+  for (const event of report.timeline) {
+    assertStructureKeys(event, guard);
+    guard.assert(event.phase);
+    guard.assert(event.outcome);
+    if (event.target) assertTargetStructure(event.target, guard);
+  }
+  for (const result of report.results) {
+    assertStructureKeys(result, guard);
+    guard.assert(result.status);
+    if (result.sideEffect) guard.assert(result.sideEffect);
+  }
+}
+async function closeSuiteClient(client) {
+  try {
+    await client?.close();
+    return {};
+  } catch (error) {
+    let retainedCleanup;
+    if (error instanceof McpFnTestClientCleanupError) {
+      retainedCleanup = () => error.retryCleanup();
+    } else if (client) {
+      retainedCleanup = () => client.close();
     }
-  })();
-  const results = execution.results;
+    const terminal = error instanceof McpFnTestClientCleanupError && error.cause !== void 0 ? error.cause : error;
+    const phase = terminal && typeof terminal === "object" && terminal.phase === "token-revocation" ? "token-revocation" : "transport-close";
+    return {
+      retainedCleanup,
+      cleanupFailure: normalizeMcpFnReportFailure({
+        name: "CleanupError",
+        message: "Target cleanup failed",
+        code: "MCPFN_TARGET_CLEANUP_FAILED",
+        phase
+      })
+    };
+  }
+}
+async function connectSuite(options, diagnostics) {
+  let client;
+  let initialClientEventRedactionOmissions = 0;
+  let manifestChecked = false;
+  let failure;
+  let execution = { results: [] };
+  try {
+    client = McpFnTestClient.createTarget(
+      options.target,
+      options.clientInfo ?? { name: "mcpfn-suite", version: "0.0.1" },
+      {
+        ...options.client,
+        diagnostics: (event) => diagnostics.record(client, event)
+      }
+    );
+    initialClientEventRedactionOmissions = client.session.getRedactionOmissionCounts().clientEvents;
+    diagnostics.captureBaseline(client);
+    await client.session.connect();
+    ({ execution, manifestChecked } = await executeConnectedSuite(client, options));
+  } catch (error) {
+    failure = safeTargetFailure(options.target, error);
+  }
+  return {
+    client,
+    initialClientEventRedactionOmissions,
+    manifestChecked,
+    failure,
+    execution
+  };
+}
+async function projectAndCloseSuite(options, diagnostics, connection) {
+  let projection;
+  let structureGuard;
+  let closeResult = {};
+  try {
+    projection = projectSuiteArtifacts(options, connection.client, connection.execution);
+    structureGuard = captureSuiteStructureGuard(
+      options.target,
+      projection,
+      diagnostics,
+      connection.failure
+    );
+  } finally {
+    closeResult = await closeSuiteClient(connection.client);
+  }
+  return { projection, structureGuard, closeResult };
+}
+function suiteIncompleteReasons(failure, cleanupFailure, diagnostics, redactionOmittedObservedEvents, overflowedObservedEvents) {
+  const reasons = [
+    ...failure ? [`${failure.layer}: ${failure.message}`] : [],
+    ...cleanupFailure ? [`Cleanup: ${cleanupFailure.message}`] : [],
+    ...diagnostics.serializationFailed ? ["Diagnostic timeline contained non-JSON data"] : [],
+    ...diagnostics.redactionFailed ? ["Diagnostic timeline redaction failed; original events omitted"] : [],
+    ...diagnostics.countExceeded ? ["Diagnostic timeline exceeded maxTimelineEvents"] : [],
+    ...diagnostics.bytesExceeded ? ["Diagnostic timeline exceeded maxReportBytes"] : [],
+    ...redactionOmittedObservedEvents > 0 ? ["Observed client events were omitted because credential redaction failed"] : [],
+    ...overflowedObservedEvents > 0 ? ["Observed client events exceeded maxObservedEvents"] : []
+  ];
+  return reasons.length ? reasons.join("; ") : void 0;
+}
+function buildSuiteReport(projection, manifestChecked, failure, cleanupFailure, diagnostics, lifecycleRedactionOmissions) {
+  const results = projection.execution.results;
   const failed = results.filter((result) => result.status === "failed").length;
   const incomplete = results.filter((result) => result.status === "incomplete").length;
-  const droppedObservedEvents = results.reduce(
+  const scenarioDroppedObservedEvents = results.reduce(
     (total, result) => total + (result.droppedObservedEvents ?? 0),
     0
   );
-  const artifactIncomplete = incomplete > 0 || droppedTimelineEvents > 0 || droppedObservedEvents > 0;
-  const report = {
+  const scenarioRedactionOmissions = results.reduce(
+    (total, result) => total + (result.redactionOmittedObservedEvents ?? 0),
+    0
+  );
+  const redactionOmittedObservedEvents = Math.max(
+    lifecycleRedactionOmissions,
+    scenarioRedactionOmissions
+  );
+  const overflowedObservedEvents = Math.max(
+    0,
+    scenarioDroppedObservedEvents - scenarioRedactionOmissions
+  );
+  const droppedObservedEvents = redactionOmittedObservedEvents + overflowedObservedEvents;
+  const artifactIncomplete = Boolean(failure) || incomplete > 0 || diagnostics.dropped > 0 || droppedObservedEvents > 0;
+  const incompleteReason = suiteIncompleteReasons(
+    failure,
+    cleanupFailure,
+    diagnostics,
+    redactionOmittedObservedEvents,
+    overflowedObservedEvents
+  );
+  return {
     formatVersion: 1,
     kind: "mcpfn.target-suite-report",
+    artifactValidation: "target-aware",
     status: artifactIncomplete ? "incomplete" : "complete",
-    runtime: { node: process.version, scenarioFormatVersion: 1 },
+    runtime: {
+      node: process.version,
+      scenarioFormatVersion: 1,
+      reportSchemaVersion: MCPFN_REPORT_SCHEMA_VERSION,
+      packages: { testing: MCPFN_TESTING_VERSION }
+    },
     ok: failed === 0 && !artifactIncomplete,
-    target: redactOAuthValue2(
-      options.target.describe()
-    ),
-    server: execution.server,
-    capabilities: execution.capabilities,
-    manifestChecked: Boolean(options.manifest),
-    ...options.manifest ? { manifestHash: options.manifest.hash } : {},
+    target: projection.target,
+    server: projection.execution.server,
+    capabilities: projection.execution.capabilities,
+    manifestChecked,
+    ...projection.manifestHash === void 0 ? {} : { manifestHash: projection.manifestHash },
     total: results.length,
     passed: results.length - failed - incomplete,
     failed,
     incomplete,
     droppedResults: 0,
     droppedObservedEvents,
-    ...droppedTimelineEvents > 0 || droppedObservedEvents > 0 ? {
-      incompleteReason: [
-        ...droppedTimelineEvents > 0 ? ["Diagnostic timeline exceeded maxTimelineEvents"] : [],
-        ...droppedObservedEvents > 0 ? ["Observed client events exceeded maxObservedEvents"] : []
-      ].join("; ")
-    } : {},
-    timeline,
-    droppedTimelineEvents,
+    ...redactionOmittedObservedEvents > 0 ? { redactionOmittedObservedEvents } : {},
+    ...incompleteReason ? { incompleteReason } : {},
+    ...failure ? { failure } : {},
+    timeline: diagnostics.timeline,
+    droppedTimelineEvents: diagnostics.dropped,
     results
   };
-  return enforceReportCap(report, maxReportBytes);
+}
+function structuralReportFailure(retainedCleanup) {
+  const failure = new McpFnClientError3(
+    "MCPFN_OPERATION_FAILED",
+    "Target report cannot be serialized because a credential conflicts with required artifact structure",
+    { phase: "capability-operation" }
+  );
+  if (retainedCleanup) {
+    throw new McpFnTargetSuiteArtifactCleanupError(retainedCleanup, failure);
+  }
+  throw failure;
+}
+function boundedSuiteReport(report, guard, maxReportBytes) {
+  const bounded = enforceReportCap(report, maxReportBytes);
+  assertSuiteReportStructure(bounded, guard);
+  return bounded;
+}
+function finalizeSuiteReport(options, projection, report, guard, maxReportBytes, retainedCleanup) {
+  let finalized;
+  try {
+    if (projection.failure) throw new Error("Report payload projection failed");
+    assertSuiteReportStructure(report, guard);
+    finalized = boundedSuiteReport(
+      redactTargetCredentials(options.target, report, { preserveKeys: true }),
+      guard,
+      maxReportBytes
+    );
+  } catch (error) {
+    if (error instanceof McpFnStructuralCredentialCollisionError) {
+      return structuralReportFailure(retainedCleanup);
+    }
+    const fallback = {
+      ...report,
+      ok: false,
+      status: "incomplete",
+      incompleteReason: reportProjectionFailureReason(error, projection.failure),
+      target: { kind: "custom" },
+      server: void 0,
+      capabilities: void 0,
+      manifestHash: void 0,
+      failure: void 0,
+      results: [],
+      timeline: [],
+      droppedResults: report.results.length,
+      droppedTimelineEvents: report.droppedTimelineEvents + report.timeline.length
+    };
+    try {
+      finalized = boundedSuiteReport(
+        redactTargetCredentials(options.target, fallback, { preserveKeys: true }),
+        guard,
+        maxReportBytes
+      );
+    } catch (fallbackError) {
+      if (fallbackError instanceof McpFnRedactionLimitError) {
+        return structuralReportFailure(retainedCleanup);
+      }
+      throw fallbackError;
+    }
+  }
+  if (retainedCleanup) throw new McpFnTargetSuiteCleanupError(finalized, retainedCleanup);
+  return finalized;
+}
+async function runTargetSuite(options) {
+  const maxTimelineEvents = options.maxTimelineEvents ?? 500;
+  if (!Number.isInteger(maxTimelineEvents) || maxTimelineEvents < 1) {
+    throw new Error("maxTimelineEvents must be a positive integer");
+  }
+  const maxReportBytes = options.maxReportBytes ?? 1048576;
+  validateReportCap(maxReportBytes);
+  const consumerDiagnostic = options.client?.diagnostics;
+  const diagnostics = new SuiteDiagnosticCollector(
+    maxTimelineEvents,
+    maxReportBytes,
+    options.target,
+    consumerDiagnostic
+  );
+  const connection = await connectSuite(options, diagnostics);
+  const { projection, structureGuard, closeResult } = await projectAndCloseSuite(
+    options,
+    diagnostics,
+    connection
+  );
+  const { cleanupFailure: closeFailure, retainedCleanup } = closeResult;
+  diagnostics.captureUnobserved(connection.client);
+  const lifecycleRedactionOmissions = Math.max(
+    0,
+    (connection.client?.session.getRedactionOmissionCounts().clientEvents ?? connection.initialClientEventRedactionOmissions) - connection.initialClientEventRedactionOmissions
+  );
+  let cleanupFailure = closeFailure;
+  cleanupFailure ??= diagnostics.cleanupFailure;
+  const failure = connection.failure ?? cleanupFailure;
+  const report = buildSuiteReport(
+    projection,
+    connection.manifestChecked,
+    failure,
+    cleanupFailure,
+    diagnostics,
+    lifecycleRedactionOmissions
+  );
+  return finalizeSuiteReport(
+    options,
+    projection,
+    report,
+    structureGuard,
+    maxReportBytes,
+    retainedCleanup
+  );
 }
 function enforceReportCap(report, maxBytes) {
   validateReportCap(maxBytes);
@@ -1916,6 +4721,10 @@ function enforceReportCap(report, maxBytes) {
     bounded.capabilities = void 0;
     bounded.timeline = [];
     bounded.droppedTimelineEvents += report.timeline.length;
+    if (bounded.failure) {
+      bounded.failure.details = void 0;
+      bounded.failure.message = "Target operation failed; details omitted to fit report budget";
+    }
   }
   if (bounded.droppedResults > 0 || jsonBytes(bounded) > maxBytes) {
     bounded.ok = false;
@@ -1939,36 +4748,65 @@ export {
   MCPFN_HOST_PROFILES,
   MCPFN_NAMED_OAUTH_HOST_FIXTURES,
   MCPFN_OAUTH_EXTENSION_GRANTS,
+  MCPFN_REPORT_SCHEMA_VERSION,
+  MCPFN_TESTING_VERSION,
   McpFnAssertionError,
   McpFnAuthAssertionError,
+  McpFnClientProfileContractCleanupError,
+  McpFnConformanceCleanupError,
   McpFnMockOAuthAuthorizationServer,
+  McpFnRedactionLimitError,
+  McpFnStructuralCredentialCollisionError,
+  McpFnTargetSuiteArtifactCleanupError,
+  McpFnTargetSuiteCleanupError,
   McpFnTestClient,
+  McpFnTestClientCleanupError,
   OFFICIAL_CONFORMANCE_VERSION,
+  acquireRemoteCredential,
   apiKeyCredential,
   assertAuthRegressionSuite,
   assertAuthorizationCodeClientMetadata,
   assertBearerResourceChallenge,
   assertManifestContract,
   assertStructuredTextParity,
+  assertTargetArtifactSafe,
+  authenticatedHttpTarget,
   bearerCredential,
+  beginTargetCredentialRedaction,
   buildOfficialConformanceArgs,
+  buildOfficialConformanceEnvironment,
   checkHostCompatibility,
   createAuthenticatedConformanceProxy,
   createFetchAuthTarget,
+  createHostedAuthorizationFixtures,
+  createMcpFnClientProfileSnapshot,
   createMcpFnScenario,
   createMcpFnScenarioArtifact,
   createMcpFnScenarioReport,
+  createMcpFnTargetSuiteJUnit,
   createOAuthClientMetadataFixture,
   createOAuthClientMetadataVariants,
   createPkcePair,
+  diffMcpFnClientProfileSnapshots,
+  disposeMcpFnTargetSuiteReport,
+  normalizeMcpFnReportFailure,
   parseBearerChallenge,
+  redactRemoteCredential,
+  redactTargetCredentials,
   runAuthRegressionSuite,
   runAuthenticatedOfficialConformance,
+  runHostedAuthorizationRegression,
+  runMcpFnClientProfileContracts,
   runMcpFnTargetSuite,
   runOfficialConformance,
   runScenarios,
+  serializeMcpFnTargetSuiteReport,
   stableJson,
   startMockOAuthAuthorizationServer,
-  validateMcpFnScenarios
+  staticRemoteCredentialProvider,
+  validateMcpFnClientProfileSnapshot,
+  validateMcpFnScenarios,
+  validateMcpFnSchemaPortability,
+  validateRemoteCredentialHeaders
 };
 //# sourceMappingURL=index.js.map