@kya-os/checkpoint-nextjs 1.2.0 → 1.7.1

package/dist/middleware-edge.js

@@ -1,10 +1,13 @@
 'use strict';
 
 var edge = require('@kya-os/checkpoint-wasm-runtime/orchestrator/edge');
-var server = require('next/server');
+var policyEdge = require('@kya-os/checkpoint-wasm-runtime/policy-edge');
 var checkpointShared = require('@kya-os/checkpoint-shared');
+var server = require('next/server');
+var composedPolicy = require('@kya-os/checkpoint-wasm-runtime/composed-policy');
 require('@kya-os/checkpoint-wasm-runtime/orchestrator');
 var adapters = require('@kya-os/checkpoint-wasm-runtime/adapters');
+var reporter = require('@kya-os/checkpoint-wasm-runtime/reporter');
 
 // src/middleware-edge.ts
 function adaptToNextResponse(rendered, req) {
@@ -55,6 +58,96 @@ function applyHeaders(res, headers) {
     res.headers.set(key, value);
   }
 }
+var DEFAULT_DASHBOARD_URL = "https://kya.vouched.id";
+var NOOP_LOGGER = {
+  shadowDivergence: () => {
+  },
+  evaluationError: () => {
+  }
+};
+function makeComposedPolicyContext(opts) {
+  const { projectId, fetcher } = opts;
+  const cache = composedPolicy.makeComposedPolicyCache({ compile: opts.compile, cacheMax: opts.cacheMax });
+  const logger = opts.logger ?? NOOP_LOGGER;
+  return {
+    async apply(result, path) {
+      const structured = { decision: result.decision, acted: false };
+      const policy = await fetcher.getPolicy(projectId);
+      const outcome = await composedPolicy.evaluateComposedPolicy({
+        cache,
+        projectId,
+        flags: {
+          policyLanguage: policy.policyLanguage,
+          policySourceText: policy.policySourceText,
+          engineEnforcementEnabled: policy.engineEnforcementEnabled,
+          enabled: policy.enabled
+        },
+        authorizeInput: composedPolicy.verifyResultToAuthorizeInput(result, { tenantId: projectId, path }),
+        baselineDecisionKind: result.decision.kind
+      });
+      if ((outcome.status === "acting" || outcome.status === "shadow") && outcome.diverged) {
+        logger.shadowDivergence({
+          projectId,
+          path,
+          engineDecision: outcome.engineDecision.kind,
+          structuredDecision: result.decision.kind,
+          detectionClass: result.detectionDetail.detectionClass.type,
+          verificationMethod: result.detectionDetail.verificationMethod,
+          confidence: result.detectionDetail.confidence,
+          agentName: result.detectionDetail.detectedAgent?.name
+        });
+      }
+      if (outcome.status === "error") {
+        logger.evaluationError(projectId, outcome.error);
+        return structured;
+      }
+      if (outcome.status === "acting") {
+        return {
+          decision: outcome.engineDecision,
+          acted: true,
+          // Echo the SSOT revision pin with the decision it produced (#3246
+          // PR5). Conditional spread: absent upstream stays absent here.
+          ...policy.policySourceHash ? { composedBlobHash: policy.policySourceHash } : {}
+        };
+      }
+      return structured;
+    },
+    async trustedDelegationRoots() {
+      const policy = await fetcher.getPolicy(projectId);
+      return policy.trustedDelegationRoots ?? [];
+    }
+  };
+}
+async function resolveTrustedDelegationRootsForRequest(resolver, headers) {
+  if (!resolver) return void 0;
+  if (!checkpointShared.requestCarriesDelegationProof(headers)) return void 0;
+  const roots = await resolver();
+  return roots.length > 0 ? roots : void 0;
+}
+async function applyComposedPolicy(context, result, path) {
+  if (!context) return;
+  try {
+    const outcome = await context.apply(result, path);
+    if (outcome.acted) {
+      result.decision = outcome.decision;
+      if (outcome.composedBlobHash) {
+        result.composedBlobHash = outcome.composedBlobHash;
+      }
+    }
+  } catch {
+  }
+}
+var consoleComposedPolicyLogger = {
+  shadowDivergence(info) {
+    console.warn("[checkpoint/composed-policy] shadow-divergence", info);
+  },
+  evaluationError(projectId, error) {
+    console.error(
+      `[checkpoint/composed-policy] evaluation failed for ${projectId}; using structured decision:`,
+      error
+    );
+  }
+};
 
 // src/translate.ts
 async function nextRequestToHttpLike(req, opts = {}) {
@@ -97,6 +190,42 @@ function extractRemoteAddress(req) {
 }
 
 // src/middleware-node.ts
+var SDK_NAME = "@kya-os/checkpoint-nextjs";
+var VERSION = "1.7.1";
+function buildReporter(config, runtime = "node") {
+  if (!config.apiKey) return null;
+  return reporter.makeDetectionReporter({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl,
+    debug: config.debug,
+    // Self-identify (incl. node-vs-edge) so the dashboard can version-gate
+    // enforcement. Next.js EDGE composed enforcement is opt-in (needs
+    // `cedarWasmModule`), so the dashboard shows it as opt-in, never "Enforcing".
+    sdk: { name: SDK_NAME, version: VERSION, runtime }
+  });
+}
+function buildTrustedRootsResolver(config, composed) {
+  if (composed?.trustedDelegationRoots) {
+    return () => composed.trustedDelegationRoots();
+  }
+  if (!config.projectId) return null;
+  const fetcher = new checkpointShared.PolicyFetcher({
+    apiBaseUrl: config.dashboardUrl ?? config.baseUrl ?? DEFAULT_DASHBOARD_URL,
+    apiKey: config.apiKey,
+    cacheTtlSeconds: config.policyCacheTtlSeconds
+  });
+  const projectId = config.projectId;
+  return async () => (await fetcher.getPolicy(projectId)).trustedDelegationRoots ?? [];
+}
+function extractReporterContext(req) {
+  return {
+    userAgent: req.headers.get("user-agent") ?? void 0,
+    ipAddress: req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? req.headers.get("x-real-ip") ?? void 0,
+    path: req.nextUrl.pathname,
+    url: req.nextUrl.href,
+    method: req.method
+  };
+}
 function buildVerifyOpts(config) {
   const overrides = config.adapters ?? {};
   return {
@@ -118,12 +247,34 @@ function buildVerifyOpts(config) {
 function withCheckpoint(config) {
   void edge.initEngineEdge();
   const opts = buildVerifyOpts(config);
+  const reporter = buildReporter(config, "edge");
+  const composed = buildComposedContext(config);
+  const trustedRootsResolver = buildTrustedRootsResolver(config, composed);
   const translateOpts = { drainJsonBody: config.drainJsonBody };
-  return async function checkpointMiddlewareEdge(req) {
+  return async function checkpointMiddlewareEdge(req, event) {
     const httpLike = await nextRequestToHttpLike(req, translateOpts);
-    const result = await edge.verifyRequestEdge(httpLike, opts);
+    const trustedDelegationRoots = await resolveTrustedDelegationRootsForRequest(
+      trustedRootsResolver,
+      req.headers
+    );
+    const result = await edge.verifyRequestEdge(
+      httpLike,
+      trustedDelegationRoots ? { ...opts, trustedDelegationRoots } : opts
+    );
+    await applyComposedPolicy(composed, result, req.nextUrl.pathname);
+    if (reporter) {
+      const reportPromise = reporter(result, extractReporterContext(req));
+      if (event) {
+        event.waitUntil(reportPromise);
+      }
+    }
     await dispatchOnResult(config, result, req);
-    const rendered = edge.renderDecisionAsResponse(result);
+    const bodyReadable200 = checkpointShared.selectBodyReadable200(
+      config.delegationChallengeMode ?? "spec-401",
+      req.headers,
+      result.detectionDetail.detectionClass
+    );
+    const rendered = edge.renderDecisionAsResponse(result, { bodyReadable200 });
     return adaptToNextResponse(rendered, req);
   };
 }
@@ -134,9 +285,28 @@ async function dispatchOnResult(config, result, req) {
   } catch {
   }
 }
+function buildComposedContext(config) {
+  if (config.composedPolicyEnforcer) return config.composedPolicyEnforcer;
+  if (!config.projectId || !config.cedarWasmModule) return null;
+  policyEdge.initPolicyEvaluatorEdge(config.cedarWasmModule);
+  return makeComposedPolicyContext({
+    projectId: config.projectId,
+    fetcher: new checkpointShared.PolicyFetcher({
+      apiBaseUrl: config.dashboardUrl ?? config.baseUrl ?? DEFAULT_DASHBOARD_URL,
+      apiKey: config.apiKey,
+      cacheTtlSeconds: config.policyCacheTtlSeconds
+    }),
+    compile: (language, source) => policyEdge.evaluatePolicy(language, source),
+    logger: config.debug ? consoleComposedPolicyLogger : void 0
+  });
+}
 
 Object.defineProperty(exports, "initEngineEdge", {
   enumerable: true,
   get: function () { return edge.initEngineEdge; }
 });
+Object.defineProperty(exports, "initPolicyEvaluatorEdge", {
+  enumerable: true,
+  get: function () { return policyEdge.initPolicyEvaluatorEdge; }
+});
 exports.withCheckpoint = withCheckpoint;

package/dist/middleware-edge.mjs

@@ -1,9 +1,13 @@
 import { initEngineEdge, verifyRequestEdge, renderDecisionAsResponse } from '@kya-os/checkpoint-wasm-runtime/orchestrator/edge';
 export { initEngineEdge } from '@kya-os/checkpoint-wasm-runtime/orchestrator/edge';
+import { initPolicyEvaluatorEdge, evaluatePolicy } from '@kya-os/checkpoint-wasm-runtime/policy-edge';
+export { initPolicyEvaluatorEdge } from '@kya-os/checkpoint-wasm-runtime/policy-edge';
+import { selectBodyReadable200, PolicyFetcher, requestCarriesDelegationProof, acceptsHtml, encodeVerdictCookie, classifyResponseShape, BLOCKED_PATH, VERDICT_COOKIE_NAME } from '@kya-os/checkpoint-shared';
 import { NextResponse } from 'next/server';
-import { acceptsHtml, encodeVerdictCookie, classifyResponseShape, BLOCKED_PATH, VERDICT_COOKIE_NAME } from '@kya-os/checkpoint-shared';
+import { makeComposedPolicyCache, evaluateComposedPolicy, verifyResultToAuthorizeInput } from '@kya-os/checkpoint-wasm-runtime/composed-policy';
 import '@kya-os/checkpoint-wasm-runtime/orchestrator';
 import { makeSystemClock, makePolicyEvaluator, makeReputationOracle, makeStatusListCache, makeDidResolver } from '@kya-os/checkpoint-wasm-runtime/adapters';
+import { makeDetectionReporter } from '@kya-os/checkpoint-wasm-runtime/reporter';
 
 // src/middleware-edge.ts
 function adaptToNextResponse(rendered, req) {
@@ -54,6 +58,96 @@ function applyHeaders(res, headers) {
     res.headers.set(key, value);
   }
 }
+var DEFAULT_DASHBOARD_URL = "https://kya.vouched.id";
+var NOOP_LOGGER = {
+  shadowDivergence: () => {
+  },
+  evaluationError: () => {
+  }
+};
+function makeComposedPolicyContext(opts) {
+  const { projectId, fetcher } = opts;
+  const cache = makeComposedPolicyCache({ compile: opts.compile, cacheMax: opts.cacheMax });
+  const logger = opts.logger ?? NOOP_LOGGER;
+  return {
+    async apply(result, path) {
+      const structured = { decision: result.decision, acted: false };
+      const policy = await fetcher.getPolicy(projectId);
+      const outcome = await evaluateComposedPolicy({
+        cache,
+        projectId,
+        flags: {
+          policyLanguage: policy.policyLanguage,
+          policySourceText: policy.policySourceText,
+          engineEnforcementEnabled: policy.engineEnforcementEnabled,
+          enabled: policy.enabled
+        },
+        authorizeInput: verifyResultToAuthorizeInput(result, { tenantId: projectId, path }),
+        baselineDecisionKind: result.decision.kind
+      });
+      if ((outcome.status === "acting" || outcome.status === "shadow") && outcome.diverged) {
+        logger.shadowDivergence({
+          projectId,
+          path,
+          engineDecision: outcome.engineDecision.kind,
+          structuredDecision: result.decision.kind,
+          detectionClass: result.detectionDetail.detectionClass.type,
+          verificationMethod: result.detectionDetail.verificationMethod,
+          confidence: result.detectionDetail.confidence,
+          agentName: result.detectionDetail.detectedAgent?.name
+        });
+      }
+      if (outcome.status === "error") {
+        logger.evaluationError(projectId, outcome.error);
+        return structured;
+      }
+      if (outcome.status === "acting") {
+        return {
+          decision: outcome.engineDecision,
+          acted: true,
+          // Echo the SSOT revision pin with the decision it produced (#3246
+          // PR5). Conditional spread: absent upstream stays absent here.
+          ...policy.policySourceHash ? { composedBlobHash: policy.policySourceHash } : {}
+        };
+      }
+      return structured;
+    },
+    async trustedDelegationRoots() {
+      const policy = await fetcher.getPolicy(projectId);
+      return policy.trustedDelegationRoots ?? [];
+    }
+  };
+}
+async function resolveTrustedDelegationRootsForRequest(resolver, headers) {
+  if (!resolver) return void 0;
+  if (!requestCarriesDelegationProof(headers)) return void 0;
+  const roots = await resolver();
+  return roots.length > 0 ? roots : void 0;
+}
+async function applyComposedPolicy(context, result, path) {
+  if (!context) return;
+  try {
+    const outcome = await context.apply(result, path);
+    if (outcome.acted) {
+      result.decision = outcome.decision;
+      if (outcome.composedBlobHash) {
+        result.composedBlobHash = outcome.composedBlobHash;
+      }
+    }
+  } catch {
+  }
+}
+var consoleComposedPolicyLogger = {
+  shadowDivergence(info) {
+    console.warn("[checkpoint/composed-policy] shadow-divergence", info);
+  },
+  evaluationError(projectId, error) {
+    console.error(
+      `[checkpoint/composed-policy] evaluation failed for ${projectId}; using structured decision:`,
+      error
+    );
+  }
+};
 
 // src/translate.ts
 async function nextRequestToHttpLike(req, opts = {}) {
@@ -96,6 +190,42 @@ function extractRemoteAddress(req) {
 }
 
 // src/middleware-node.ts
+var SDK_NAME = "@kya-os/checkpoint-nextjs";
+var VERSION = "1.7.1";
+function buildReporter(config, runtime = "node") {
+  if (!config.apiKey) return null;
+  return makeDetectionReporter({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl,
+    debug: config.debug,
+    // Self-identify (incl. node-vs-edge) so the dashboard can version-gate
+    // enforcement. Next.js EDGE composed enforcement is opt-in (needs
+    // `cedarWasmModule`), so the dashboard shows it as opt-in, never "Enforcing".
+    sdk: { name: SDK_NAME, version: VERSION, runtime }
+  });
+}
+function buildTrustedRootsResolver(config, composed) {
+  if (composed?.trustedDelegationRoots) {
+    return () => composed.trustedDelegationRoots();
+  }
+  if (!config.projectId) return null;
+  const fetcher = new PolicyFetcher({
+    apiBaseUrl: config.dashboardUrl ?? config.baseUrl ?? DEFAULT_DASHBOARD_URL,
+    apiKey: config.apiKey,
+    cacheTtlSeconds: config.policyCacheTtlSeconds
+  });
+  const projectId = config.projectId;
+  return async () => (await fetcher.getPolicy(projectId)).trustedDelegationRoots ?? [];
+}
+function extractReporterContext(req) {
+  return {
+    userAgent: req.headers.get("user-agent") ?? void 0,
+    ipAddress: req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? req.headers.get("x-real-ip") ?? void 0,
+    path: req.nextUrl.pathname,
+    url: req.nextUrl.href,
+    method: req.method
+  };
+}
 function buildVerifyOpts(config) {
   const overrides = config.adapters ?? {};
   return {
@@ -117,12 +247,34 @@ function buildVerifyOpts(config) {
 function withCheckpoint(config) {
   void initEngineEdge();
   const opts = buildVerifyOpts(config);
+  const reporter = buildReporter(config, "edge");
+  const composed = buildComposedContext(config);
+  const trustedRootsResolver = buildTrustedRootsResolver(config, composed);
   const translateOpts = { drainJsonBody: config.drainJsonBody };
-  return async function checkpointMiddlewareEdge(req) {
+  return async function checkpointMiddlewareEdge(req, event) {
     const httpLike = await nextRequestToHttpLike(req, translateOpts);
-    const result = await verifyRequestEdge(httpLike, opts);
+    const trustedDelegationRoots = await resolveTrustedDelegationRootsForRequest(
+      trustedRootsResolver,
+      req.headers
+    );
+    const result = await verifyRequestEdge(
+      httpLike,
+      trustedDelegationRoots ? { ...opts, trustedDelegationRoots } : opts
+    );
+    await applyComposedPolicy(composed, result, req.nextUrl.pathname);
+    if (reporter) {
+      const reportPromise = reporter(result, extractReporterContext(req));
+      if (event) {
+        event.waitUntil(reportPromise);
+      }
+    }
     await dispatchOnResult(config, result, req);
-    const rendered = renderDecisionAsResponse(result);
+    const bodyReadable200 = selectBodyReadable200(
+      config.delegationChallengeMode ?? "spec-401",
+      req.headers,
+      result.detectionDetail.detectionClass
+    );
+    const rendered = renderDecisionAsResponse(result, { bodyReadable200 });
     return adaptToNextResponse(rendered, req);
   };
 }
@@ -133,5 +285,20 @@ async function dispatchOnResult(config, result, req) {
   } catch {
   }
 }
+function buildComposedContext(config) {
+  if (config.composedPolicyEnforcer) return config.composedPolicyEnforcer;
+  if (!config.projectId || !config.cedarWasmModule) return null;
+  initPolicyEvaluatorEdge(config.cedarWasmModule);
+  return makeComposedPolicyContext({
+    projectId: config.projectId,
+    fetcher: new PolicyFetcher({
+      apiBaseUrl: config.dashboardUrl ?? config.baseUrl ?? DEFAULT_DASHBOARD_URL,
+      apiKey: config.apiKey,
+      cacheTtlSeconds: config.policyCacheTtlSeconds
+    }),
+    compile: (language, source) => evaluatePolicy(language, source),
+    logger: config.debug ? consoleComposedPolicyLogger : void 0
+  });
+}
 
 export { withCheckpoint };

package/dist/middleware-node.d.mts

@@ -1,113 +1,12 @@
+import * as _kya_os_checkpoint_wasm_runtime_engine from '@kya-os/checkpoint-wasm-runtime/engine';
 import * as _kya_os_checkpoint_wasm_runtime_adapters from '@kya-os/checkpoint-wasm-runtime/adapters';
-import { DidResolverAdapter, StatusListCacheAdapter, ReputationOracleAdapter, PolicyEvaluatorAdapter } from '@kya-os/checkpoint-wasm-runtime/adapters';
-import { NextRequest, NextResponse } from 'next/server';
-import { EnforcementMode, VerifyResult, EngineConfig } from '@kya-os/checkpoint-wasm-runtime/engine';
+import { NextRequest, NextFetchEvent, NextResponse } from 'next/server';
+import { DetectionReporter, ReporterContext } from '@kya-os/checkpoint-wasm-runtime/reporter';
+import { C as CheckpointConfig } from './config-DAwIA4DB.mjs';
+import { ComposedPolicyContext, TrustedDelegationRootsResolver } from './composed-policy.mjs';
+import '@kya-os/checkpoint-shared';
+import '@kya-os/checkpoint-wasm-runtime/composed-policy';
 
-/**
- * Configuration for `withCheckpoint`.
- *
- * The new minimal shape Phase D's middleware needs. Legacy
- * `AgentShieldMiddlewareConfig` (from `./api-middleware`) remains
- * exported during the deprecation window — see D.4 cutover.
- */
-interface CheckpointConfig {
-    /**
-     * Tenant identifier — typically the customer's dashboard hostname
-     * (e.g. `acme.checkpoint.example`). The PolicyEvaluator uses this
-     * to look up tenant policy from the dashboard.
-     */
-    tenantHost: string;
-    /**
-     * `'enforce'` (default) blocks; `'observe'` passes everything
-     * through with `X-Checkpoint-Would-Have-Been` headers. Per Phase 0.2.
-     */
-    enforcementMode?: EnforcementMode;
-    /**
-     * Argus reputation oracle base URL. Omit to use the trust-by-default
-     * baseline (reputation defaults to 1.0; orchestrator logs a one-shot
-     * warning at first request).
-     */
-    argusUrl?: string;
-    /**
-     * Dashboard base URL for the PolicyEvaluator to fetch tenant policy
-     * from. Omit to use the open-by-default tenant policy.
-     */
-    dashboardUrl?: string;
-    /**
-     * Returned to the PolicyEvaluator for anonymous requests (no agent
-     * DID). Default 1.0 (trust-by-default).
-     */
-    reputationBaseline?: number;
-    /**
-     * Pre-built adapter instances. Production deployments use the
-     * factory-built defaults from `@kya-os/checkpoint-wasm-runtime/adapters`;
-     * tests use stubs. The factory composes any provided overrides over
-     * defaults — partial overrides are supported.
-     */
-    adapters?: Partial<{
-        didResolver: DidResolverAdapter;
-        statusListCache: StatusListCacheAdapter;
-        reputationOracle: ReputationOracleAdapter;
-        policyEvaluator: PolicyEvaluatorAdapter;
-    }>;
-    /**
-     * Optional callback for the post-verdict path — fires after every
-     * verification, regardless of permit/block, with the full
-     * `VerifyResult`. Use for logging, dashboards, telemetry. Errors
-     * thrown here are swallowed so user code can't break the middleware
-     * response.
-     */
-    onResult?: (result: VerifyResult, req: NextRequest) => void | Promise<void>;
-    /**
-     * Accept legacy `KYA-Delegation`-header envelope form alongside the
-     * canonical `_meta.proof.jws` body form. Default `false`.
-     *
-     * **When to enable** — customers whose agents pre-date Envelope-1
-     * (#2537) and ship MCP-I proofs as `{protected,payload,signature}`
-     * JSON in a `KYA-Delegation` HTTP header. Post-Envelope-1 agents
-     * ship compact JWS in the request body's `_meta.proof.jws` field;
-     * those don't need this flag.
-     *
-     * Forwarded to the orchestrator's `VerifyRequestOpts.legacyEnvelopeFallback`.
-     * Both transports (header + body) are honored when this is `true`;
-     * the orchestrator's detection order is body first, then header
-     * (`packages/checkpoint-wasm-runtime/src/engine/orchestrator/build-agent-request.ts`).
-     *
-     * SDK-Envelope-Plumbing-1 (#2594). Added in `@kya-os/checkpoint-nextjs@1.1.0`.
-     */
-    legacyEnvelopeFallback?: boolean;
-    /**
-     * Read the request body when `content-type` is `application/json` so
-     * the orchestrator can extract an MCP-I envelope from
-     * `_meta.proof.jws`. Default `true`.
-     *
-     * **When to disable** — streaming middlewares that can't tolerate
-     * the `req.clone()` memory overhead (one full-body copy is buffered
-     * during the read). For those, set `false` and route MCP-I
-     * envelopes through the `KYA-Delegation` header transport instead
-     * (requires `legacyEnvelopeFallback: true`).
-     *
-     * The clone preserves `req.body` for downstream handlers — disabling
-     * is a performance optimization, not a correctness fix.
-     *
-     * SDK-Envelope-Plumbing-1 (#2594). Added in `@kya-os/checkpoint-nextjs@1.1.0`.
-     */
-    drainJsonBody?: boolean;
-    /**
-     * Engine-default behaviour knobs forwarded to every composed
-     * `ContextSpec`. Defaults to `{ tier3Action: 'monitor' }` —
-     * customer-onboarding-safe (tenant policy decides; engine doesn't
-     * short-circuit known-agent UAs with an engine-default Block).
-     *
-     * Opt into `{ tier3Action: 'block' }` when the host wants the
-     * calibrated engine-default block for KnownAiAgent / AiCrawler /
-     * HeadlessBrowser classifications BEFORE the tenant policy seam.
-     *
-     * Added in `@kya-os/checkpoint-nextjs@1.2.0` (Engine-Tier3-Monitor-
-     * Default, #2653 + this PR's plumbing follow-up).
-     */
-    engineConfig?: EngineConfig;
-}
 /**
  * Build the Checkpoint middleware. Returns a function `(req) => NextResponse`
  * suitable for `export default withCheckpoint({...})` in `middleware.ts`.
@@ -117,24 +16,48 @@ interface CheckpointConfig {
  * `verifyRequest`, and translates the verdict to `NextResponse`. No
  * verification logic lives in this file.
  */
-declare function withCheckpoint(config: CheckpointConfig): (req: NextRequest) => Promise<NextResponse>;
+declare function withCheckpoint(config: CheckpointConfig): (req: NextRequest, event?: NextFetchEvent) => Promise<NextResponse>;
+/**
+ * Installed SDK version, self-reported to the detection reporter so the
+ * dashboard can version-gate "composed policy enforces here". MUST equal
+ * `package.json` version — pinned by a unit test (the old hardcoded `0.1.0` had
+ * drifted). Re-exported as `VERSION` from the package index.
+ */
+declare const VERSION = "1.7.1";
+declare function buildReporter(config: CheckpointConfig, runtime?: 'node' | 'edge'): DetectionReporter | null;
+/**
+ * Build the per-factory trusted-delegation-roots resolver (P2 / DR-1). Root
+ * pinning is a security concern INDEPENDENT of composed Cedar enforcement, so it
+ * must resolve wherever a `projectId` exists — including Edge setups that never
+ * wire `cedarWasmModule` (where `buildComposedContext` returns null). Prefers the
+ * composed context's accessor (reuses its cached fetcher / honors an injected
+ * enforcer); otherwise falls back to a `projectId`-only policy fetch. Returns
+ * `null` when no source is configured (no roots → engine open default).
+ */
+declare function buildTrustedRootsResolver(config: CheckpointConfig, composed: ComposedPolicyContext | null): TrustedDelegationRootsResolver | null;
+/**
+ * Pull the request context the dashboard's `/api/v1/log-detection`
+ * endpoint expects out of a `NextRequest`. Works under both Node and
+ * Edge runtimes — no runtime-specific APIs.
+ */
+declare function extractReporterContext(req: NextRequest): ReporterContext;
 /**
  * Compose adapter defaults with caller-supplied overrides. Factored
  * out so the Edge entry (which uses the same composition) can reuse
  * the shape.
  */
 declare function buildVerifyOpts(config: CheckpointConfig): {
-    didResolver: DidResolverAdapter;
-    statusListCache: StatusListCacheAdapter;
-    reputationOracle: ReputationOracleAdapter;
-    policyEvaluator: PolicyEvaluatorAdapter;
+    didResolver: _kya_os_checkpoint_wasm_runtime_adapters.DidResolverAdapter;
+    statusListCache: _kya_os_checkpoint_wasm_runtime_adapters.StatusListCacheAdapter;
+    reputationOracle: _kya_os_checkpoint_wasm_runtime_adapters.ReputationOracleAdapter;
+    policyEvaluator: _kya_os_checkpoint_wasm_runtime_adapters.PolicyEvaluatorAdapter;
     clock: _kya_os_checkpoint_wasm_runtime_adapters.ClockAdapter;
     tenantHost: string;
-    enforcementMode: EnforcementMode;
+    enforcementMode: _kya_os_checkpoint_wasm_runtime_engine.EnforcementMode;
     reputationBaseline: number | undefined;
     argusUrl: string | undefined;
     legacyEnvelopeFallback: boolean;
-    engineConfig: EngineConfig | undefined;
+    engineConfig: _kya_os_checkpoint_wasm_runtime_engine.EngineConfig | undefined;
 };
 
-export { type CheckpointConfig, buildVerifyOpts as _buildVerifyOpts, withCheckpoint };
+export { CheckpointConfig, VERSION, buildReporter as _buildReporter, buildTrustedRootsResolver as _buildTrustedRootsResolver, buildVerifyOpts as _buildVerifyOpts, extractReporterContext as _extractReporterContext, withCheckpoint };