@cassiomc1/forgeloop 1.12.0 → 1.14.0

package/src/core/router.js

@@ -62,7 +62,21 @@ const SIGNALS = Object.freeze({
   platforms: new Set(["web", "mobile", "desktop", "server", "ci", "cross-platform"]),
 });
 
-const PROJECT_FRAMEWORKS = new Set(["flutter"]);
+const PROJECT_FRAMEWORKS = new Set([
+  "flutter", "dotnet", "aspnetcore", "abp", "nodejs", "rust",
+  "c", "cpp", "java", "sql", "go", "typescript", "php", "swift",
+]);
+
+const LANGUAGE_PROJECT_GUIDES = Object.freeze([
+  ["c", "PROJECT_C_CONFIRMED"],
+  ["cpp", "PROJECT_CPP_CONFIRMED"],
+  ["java", "PROJECT_JAVA_CONFIRMED"],
+  ["go", "PROJECT_GO_CONFIRMED"],
+  ["typescript", "PROJECT_TYPESCRIPT_CONFIRMED"],
+  ["php", "PROJECT_PHP_CONFIRMED"],
+  ["swift", "PROJECT_SWIFT_CONFIRMED"],
+  ["sql", "PROJECT_SQL_CONFIRMED"],
+]);
 
 export const PLATFORM_SEMANTICS = Object.freeze({
   web: Object.freeze({
@@ -134,8 +148,100 @@ function addFlutterProjectGuides(input, add) {
     || !["MATCH", "UNSCOPED"].includes(projectEvidence.scope)
     || !hasFlutterWorkContext(input.workType)) return;
   add("flutter", "PROJECT_FLUTTER_SDK_DEPENDENCY");
-  add("clean", "PROJECT_FLUTTER_BASELINE");
-  add("test", "PROJECT_FLUTTER_BASELINE");
+}
+
+function hasDotNetWorkContext(workType) {
+  return !["documentation", "ui-copy"].includes(workType);
+}
+
+function addDotNetProjectGuides(input, add) {
+  const projectEvidence = input.projectEvidence;
+  if (!projectEvidence?.frameworks.includes("dotnet")
+    || !["MATCH", "UNSCOPED"].includes(projectEvidence.scope)
+    || !hasDotNetWorkContext(input.workType)) return;
+  add("dotnet", "PROJECT_DOTNET_SDK_PROJECT");
+  if (projectEvidence.frameworks.includes("aspnetcore")) add("dotnet", "PROJECT_ASPNETCORE_CONFIRMED");
+  if (projectEvidence.frameworks.includes("abp")) add("dotnet", "PROJECT_ABP_CONFIRMED");
+}
+
+function hasNodeJsWorkContext(workType) {
+  return !["documentation", "ui-copy", "mobile-ui"].includes(workType);
+}
+
+function addNodeJsProjectGuides(input, add) {
+  const projectEvidence = input.projectEvidence;
+  if (!projectEvidence?.frameworks.includes("nodejs")
+    || !["MATCH", "UNSCOPED"].includes(projectEvidence.scope)
+    || !hasNodeJsWorkContext(input.workType)) return;
+  add("nodejs", "PROJECT_NODEJS_CONFIRMED");
+  if (projectEvidence.primarySignals.some((signal) => signal.includes(":dependencies.") || signal.includes(":optionalDependencies."))) {
+    add("nodejs", "PROJECT_NODEJS_BACKEND_FRAMEWORK");
+  }
+  if (projectEvidence.primarySignals.some((signal) => signal.includes(":scripts."))) {
+    add("nodejs", "PROJECT_NODEJS_RUNTIME_SCRIPT");
+  }
+  if (projectEvidence.primarySignals.some((signal) => signal.includes(":import="))) {
+    add("nodejs", "PROJECT_NODEJS_SERVER_RUNTIME");
+  }
+}
+
+function hasRustWorkContext(workType) {
+  return !["documentation", "ui-copy", "mobile-ui"].includes(workType);
+}
+
+function addRustProjectGuides(input, add) {
+  const projectEvidence = input.projectEvidence;
+  if (!projectEvidence?.frameworks.includes("rust")
+    || !["MATCH", "UNSCOPED"].includes(projectEvidence.scope)
+    || !hasRustWorkContext(input.workType)) return;
+  add("rust", "PROJECT_RUST_CONFIRMED");
+  if (projectEvidence.primarySignals.some((signal) => signal.endsWith(":package"))) {
+    add("rust", "PROJECT_RUST_CARGO_PACKAGE");
+  }
+  if (projectEvidence.primarySignals.some((signal) => signal.endsWith(":workspace"))) {
+    add("rust", "PROJECT_RUST_CARGO_WORKSPACE");
+  }
+}
+
+function hasLanguageWorkContext(workType) {
+  return !["documentation", "ui-copy"].includes(workType);
+}
+
+function addLanguageProjectGuides(input, add) {
+  const projectEvidence = input.projectEvidence;
+  if (!projectEvidence || !["MATCH", "UNSCOPED"].includes(projectEvidence.scope)
+    || !hasLanguageWorkContext(input.workType)) return;
+  for (const [guide, reason] of LANGUAGE_PROJECT_GUIDES) {
+    if (projectEvidence.frameworks.includes(guide)) add(guide, reason);
+  }
+}
+
+function addProjectBaselineGuides(input, add) {
+  const projectEvidence = input.projectEvidence;
+  if (!projectEvidence || !["MATCH", "UNSCOPED"].includes(projectEvidence.scope)) return;
+  if (projectEvidence.frameworks.includes("flutter") && hasFlutterWorkContext(input.workType)) {
+    add("clean", "PROJECT_FLUTTER_BASELINE");
+    add("test", "PROJECT_FLUTTER_BASELINE");
+  }
+  if (projectEvidence.frameworks.includes("dotnet") && hasDotNetWorkContext(input.workType)) {
+    add("clean", "PROJECT_DOTNET_BASELINE");
+    add("test", "PROJECT_DOTNET_BASELINE");
+  }
+  if (projectEvidence.frameworks.includes("nodejs") && hasNodeJsWorkContext(input.workType)) {
+    add("clean", "PROJECT_NODEJS_BASELINE");
+    add("test", "PROJECT_NODEJS_BASELINE");
+  }
+  if (projectEvidence.frameworks.includes("rust") && hasRustWorkContext(input.workType)) {
+    add("clean", "PROJECT_RUST_BASELINE");
+    add("test", "PROJECT_RUST_BASELINE");
+  }
+  if (hasLanguageWorkContext(input.workType)) {
+    for (const [language] of LANGUAGE_PROJECT_GUIDES) {
+      if (!projectEvidence.frameworks.includes(language)) continue;
+      add("clean", `PROJECT_${language.toUpperCase()}_BASELINE`);
+      add("test", `PROJECT_${language.toUpperCase()}_BASELINE`);
+    }
+  }
 }
 
 function flutterExclusionReason(projectEvidence, workType) {
@@ -146,6 +252,30 @@ function flutterExclusionReason(projectEvidence, workType) {
   return "NO_FLUTTER_PRIMARY_EVIDENCE";
 }
 
+function dotNetExclusionReason(projectEvidence, workType) {
+  if (!projectEvidence) return "NO_DOTNET_PROJECT_EVIDENCE";
+  if (projectEvidence.scope === "NO_MATCH") return "NO_DOTNET_SCOPE_MATCH";
+  if (!projectEvidence.frameworks.includes("dotnet")) return "NO_DOTNET_PRIMARY_EVIDENCE";
+  if (!hasDotNetWorkContext(workType)) return "NO_DOTNET_EXECUTABLE_WORK";
+  return "NO_DOTNET_PRIMARY_EVIDENCE";
+}
+
+function nodeJsExclusionReason(projectEvidence, workType) {
+  if (!projectEvidence) return "NO_NODEJS_PROJECT_EVIDENCE";
+  if (projectEvidence.scope === "NO_MATCH") return "NO_NODEJS_SCOPE_MATCH";
+  if (!projectEvidence.frameworks.includes("nodejs")) return "NO_NODEJS_PRIMARY_EVIDENCE";
+  if (!hasNodeJsWorkContext(workType)) return "NO_NODEJS_EXECUTABLE_WORK";
+  return "NO_NODEJS_PRIMARY_EVIDENCE";
+}
+
+function rustExclusionReason(projectEvidence, workType) {
+  if (!projectEvidence) return "NO_RUST_PROJECT_EVIDENCE";
+  if (projectEvidence.scope === "NO_MATCH") return "NO_RUST_SCOPE_MATCH";
+  if (!projectEvidence.frameworks.includes("rust")) return "NO_RUST_PRIMARY_EVIDENCE";
+  if (!hasRustWorkContext(workType)) return "NO_RUST_EXECUTABLE_WORK";
+  return "NO_RUST_PRIMARY_EVIDENCE";
+}
+
 function exclusionReasonForGuide(guide, projectEvidence, workType) {
   if (guide === "security") return "NO_TRUST_BOUNDARY";
   if (guide === "performance") return "NO_MEASURABLE_PERFORMANCE_RISK";
@@ -154,6 +284,16 @@ function exclusionReasonForGuide(guide, projectEvidence, workType) {
   if (guide === "taste") return "NO_TASTE_FRONTEND_CONTEXT";
   if (guide === "documentation") return "NO_DOCUMENTATION_SURFACE";
   if (guide === "flutter") return flutterExclusionReason(projectEvidence, workType);
+  if (guide === "dotnet") return dotNetExclusionReason(projectEvidence, workType);
+  if (guide === "nodejs") return nodeJsExclusionReason(projectEvidence, workType);
+  if (guide === "rust") return rustExclusionReason(projectEvidence, workType);
+  if (LANGUAGE_PROJECT_GUIDES.some(([language]) => language === guide)) {
+    if (!projectEvidence) return `NO_${guide.toUpperCase()}_PROJECT_EVIDENCE`;
+    if (projectEvidence.scope === "NO_MATCH") return `NO_${guide.toUpperCase()}_SCOPE_MATCH`;
+    if (!projectEvidence.frameworks.includes(guide)) return `NO_${guide.toUpperCase()}_PRIMARY_EVIDENCE`;
+    if (!hasLanguageWorkContext(workType)) return `NO_${guide.toUpperCase()}_EXECUTABLE_WORK`;
+    return `NO_${guide.toUpperCase()}_PRIMARY_EVIDENCE`;
+  }
   return "NO_BEHAVIOR_OR_EXECUTABLE_CHANGE";
 }
 
@@ -173,6 +313,64 @@ function reasonForSignal(prefix, signal) {
   return `${prefix}_${signal.toUpperCase().replaceAll("-", "_")}`;
 }
 
+const SECURITY_TRUST_BOUNDARY_RISKS = Object.freeze([
+  "untrusted-input", "personal-data", "secrets", "external-service", "publication",
+]);
+
+// Canonical deterministic safety floor. These are the route reason codes the
+// router assigns when a trust-boundary signal selects the security guide. The
+// semantic exclusion policy reads protection from this same source, so a
+// mandatory safety guide can never drift out of protection (for example the
+// previously missing external-service boundary).
+const MANDATORY_SAFETY_REASONS = Object.freeze(new Set([
+  "SURFACE_AUTH",
+  ...SECURITY_TRUST_BOUNDARY_RISKS.map((risk) => reasonForSignal("RISK", risk)),
+]));
+
+export function isMandatorySafetyReason(reason) {
+  return MANDATORY_SAFETY_REASONS.has(reason);
+}
+
+export function isMandatorySafetyGuide(guide, reasons) {
+  return guide === "security"
+    && Array.isArray(reasons)
+    && reasons.some((reason) => isMandatorySafetyReason(reason));
+}
+
+function applySemanticGuideRecommendation(selected, excluded, recommendation) {
+  const guideDecision = recommendation?.guideRelevance
+    ?? (recommendation?.rankedIds || recommendation?.excludedIds ? recommendation : null);
+  if (!guideDecision) return;
+  const excludedIds = new Set(Array.isArray(guideDecision.excludedIds) ? guideDecision.excludedIds : []);
+  const confidenceById = guideDecision.confidenceById ?? {};
+  for (const guide of [...selected.keys()]) {
+    const reasons = selected.get(guide);
+    if (isMandatorySafetyGuide(guide, reasons)) {
+      if (!reasons.includes("MANDATORY_SAFETY_GUIDE")) reasons.push("MANDATORY_SAFETY_GUIDE");
+      continue;
+    }
+    if (!excludedIds.has(guide)) {
+      if (!reasons.includes("JEV_RELEVANT")) reasons.push("JEV_RELEVANT");
+      continue;
+    }
+    if ((confidenceById[guide] ?? 0) < 0.75) {
+      if (!reasons.includes("JEV_LOW_CONFIDENCE_RETAINED")) reasons.push("JEV_LOW_CONFIDENCE_RETAINED");
+      continue;
+    }
+    selected.delete(guide);
+    excluded[guide] = ["JEV_EXCLUDED"];
+  }
+  const ranked = Array.isArray(guideDecision.rankedIds) ? guideDecision.rankedIds : [];
+  const order = new Map(ranked.map((guide, index) => [guide, index]));
+  const entries = [...selected.entries()].sort((left, right) => {
+    const leftRank = order.has(left[0]) ? order.get(left[0]) : ranked.length + [...selected.keys()].indexOf(left[0]);
+    const rightRank = order.has(right[0]) ? order.get(right[0]) : ranked.length + [...selected.keys()].indexOf(right[0]);
+    return leftRank - rightRank;
+  });
+  selected.clear();
+  for (const [guide, reasons] of entries) selected.set(guide, reasons);
+}
+
 function normalizeArray(value, name, allowed) {
   if (value === undefined) return [];
   if (!Array.isArray(value)) throw new RouteInputError(`${name} must be an array`);
@@ -209,6 +407,14 @@ function normalizeProjectEvidence(value) {
     throw new RouteInputError(`Unsupported projectEvidence schema version: ${value.schemaVersion}`);
   }
   const frameworks = normalizeArray(value.frameworks, "frameworks", PROJECT_FRAMEWORKS);
+  const hasDotnet = frameworks.includes("dotnet");
+  const invalidOverlays = frameworks.filter((framework) => framework === "aspnetcore" || framework === "abp");
+  if (!hasDotnet && invalidOverlays.length > 0) {
+    const noun = invalidOverlays.length === 1 ? "framework" : "frameworks";
+    const verb = invalidOverlays.length === 1 ? "requires" : "require";
+    const labels = invalidOverlays.map((framework) => `"${framework}"`).join(", ");
+    throw new RouteInputError(`projectEvidence ${noun} ${labels} ${verb} "dotnet"`);
+  }
   const scope = value.scope ?? (frameworks.length > 0 ? "UNSCOPED" : "NONE");
   if (!PROJECT_EVIDENCE_SCOPES.includes(scope)) {
     throw new RouteInputError(`Unknown project evidence scope: ${scope}`);
@@ -264,6 +470,11 @@ export function evaluateRoute(input = {}, profileOptions = {}) {
 
   const projectEvidence = normalized.projectEvidence;
   addFlutterProjectGuides(normalized, add);
+  addDotNetProjectGuides(normalized, add);
+  addNodeJsProjectGuides(normalized, add);
+  addRustProjectGuides(normalized, add);
+  addLanguageProjectGuides(normalized, add);
+  addProjectBaselineGuides(normalized, add);
 
   const workReason = reasonForWorkType(normalized.workType);
   for (const guide of WORK_GUIDES[normalized.workType]) add(guide, workReason);
@@ -287,7 +498,7 @@ export function evaluateRoute(input = {}, profileOptions = {}) {
   }
 
   for (const risk of normalized.risks) {
-    if (["untrusted-input", "personal-data", "secrets", "external-service", "publication"].includes(risk)) {
+    if (SECURITY_TRUST_BOUNDARY_RISKS.includes(risk)) {
       add("security", reasonForSignal("RISK", risk));
     }
     if (["critical-path", "performance"].includes(risk)) {
@@ -328,12 +539,19 @@ export function evaluateRoute(input = {}, profileOptions = {}) {
     excluded[guide] = [exclusionReasonForGuide(guide, projectEvidence, normalized.workType)];
   }
 
+  applySemanticGuideRecommendation(
+    selected,
+    excluded,
+    profileOptions.semanticRecommendation ?? null,
+  );
+
   const guides = [...selected.keys()];
   const result = {
     schemaVersion: ROUTING_SCHEMA_VERSION,
     protocolVersion: PROTOCOL_VERSION,
     input: normalized,
     primary: Object.prototype.hasOwnProperty.call(PRIMARY_GUIDES, normalized.workType)
+      && guides.includes(PRIMARY_GUIDES[normalized.workType])
       ? PRIMARY_GUIDES[normalized.workType]
       : guides[0] ?? null,
     guides,
@@ -346,6 +564,7 @@ export function evaluateRoute(input = {}, profileOptions = {}) {
       configuredProfile: profileOptions.configuredProfile ?? input.configuredProfile ?? "auto",
       requestedProfile: profileOptions.requestedProfile
         ?? (Object.prototype.hasOwnProperty.call(input, "executionProfile") ? input.executionProfile : null),
+      semanticRecommendation: profileOptions.semanticRecommendation ?? null,
     }),
   };
   return assertRouteInvariants(result);

package/src/core/runtime-context.js

@@ -4,8 +4,22 @@ import {
   normalizeVerificationExecutionPolicy,
 } from "./verification-execution.js";
 import { STRUCTURAL_QUALITY_PROVIDER_ID_PATTERN } from "./structural-quality/constants.js";
-import { E_ADVISORY_CONTEXT_PROVIDER_INVALID } from "./error-codes.js";
+import {
+  E_ADVISORY_CONTEXT_PROVIDER_INVALID,
+  E_BROWSER_VERIFICATION_PROVIDER_INVALID,
+  E_SECURITY_REVIEW_PROVIDER_INVALID,
+} from "./error-codes.js";
 import { assertAdvisoryContextProviderIdentity } from "./advisory-context/provider.js";
+import {
+  BROWSER_VERIFICATION_PROVIDER_ID_PATTERN,
+  assertBrowserVerificationProvider,
+  assertBrowserVerificationProviderIdentity,
+} from "./browser-verification/provider.js";
+import {
+  SECURITY_REVIEW_PROVIDER_ID_PATTERN,
+  assertSecurityReviewProvider,
+  assertSecurityReviewProviderIdentity,
+} from "./security-review/provider.js";
 
 export const AUTHORITY_TRUST_MODES = Object.freeze(["NONE", "HOST_ATTESTED"]);
 
@@ -83,6 +97,100 @@ export function resolveAuthorityContext(options = {}) {
   return hasDirectAuthority ? createAuthorityContext({ ...source, trustMode: "NONE" }) : createAuthorityContext();
 }
 
+function isProviderObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value);
+}
+
+function providerEntries(configured, label, code) {
+  if (!configured || typeof configured !== "object" || Array.isArray(configured)) {
+    const error = new Error(`${label} must be an object or Map`);
+    error.code = code;
+    throw error;
+  }
+  return configured instanceof Map ? [...configured.entries()] : Object.entries(configured);
+}
+
+function registerProviders(configured, { label, code, idError, validateId, providerError, validateProvider }) {
+  const providers = {};
+  for (const [id, provider] of providerEntries(configured, label, code)) {
+    if (!validateId(id)) {
+      const error = new Error(idError(id));
+      error.code = code;
+      throw error;
+    }
+    if (typeof provider !== "function" && !isProviderObject(provider)) {
+      const error = new Error(providerError(id));
+      error.code = code;
+      throw error;
+    }
+    if (typeof provider !== "function") validateProvider(provider, id);
+    providers[id] = provider;
+  }
+  return Object.freeze(providers);
+}
+
+function configureUsageProvider(context, provider) {
+  if (!provider
+    || typeof provider !== "object"
+    || Array.isArray(provider)
+    || typeof provider.getTaskUsage !== "function") {
+    const error = new Error("Usage provider must expose getTaskUsage({ projectPath, taskId })");
+    error.code = "E_USAGE_INVALID";
+    throw error;
+  }
+  context.usageProvider = provider;
+}
+
+function configureStructuralQualityProviders(context, configured) {
+  context.structuralQualityProviders = registerProviders(configured, {
+    label: "structuralQualityProviders",
+    code: "E_STRUCTURAL_QUALITY_PROVIDER_INVALID",
+    idError: id => `Invalid or reserved structural-quality provider ID: ${id}`,
+    validateId: id => STRUCTURAL_QUALITY_PROVIDER_ID_PATTERN.test(id) && id !== "sentrux",
+    providerError: id => `Structural-quality provider ${id} must be an object or factory`,
+    validateProvider: (provider, id) => {},
+  });
+}
+
+function configureAdvisoryContextProviders(context, configured) {
+  context.advisoryContextProviders = registerProviders(configured, {
+    label: "advisoryContextProviders",
+    code: E_ADVISORY_CONTEXT_PROVIDER_INVALID,
+    idError: id => `Invalid advisory-context provider ID: ${id}`,
+    validateId: id => /^[a-z0-9][a-z0-9_-]*$/.test(id),
+    providerError: id => `Advisory-context provider ${id} must be an object or factory`,
+    validateProvider: assertAdvisoryContextProviderIdentity,
+  });
+}
+
+function configureBrowserVerificationProviders(context, configured) {
+  context.browserVerificationProviders = registerProviders(configured, {
+    label: "browserVerificationProviders",
+    code: E_BROWSER_VERIFICATION_PROVIDER_INVALID,
+    idError: id => `Invalid browser-verification provider ID: ${id}`,
+    validateId: id => BROWSER_VERIFICATION_PROVIDER_ID_PATTERN.test(id),
+    providerError: id => `Browser-verification provider ${id} must be an object with verify() or a factory`,
+    validateProvider: (provider, id) => {
+      assertBrowserVerificationProviderIdentity(provider, { expectedId: id });
+      assertBrowserVerificationProvider(provider, { label: `browser-verification provider "${id}"` });
+    },
+  });
+}
+
+function configureSecurityReviewProviders(context, configured) {
+  context.securityReviewProviders = registerProviders(configured, {
+    label: "securityReviewProviders",
+    code: E_SECURITY_REVIEW_PROVIDER_INVALID,
+    idError: id => `Invalid security-review provider ID: ${id}`,
+    validateId: id => SECURITY_REVIEW_PROVIDER_ID_PATTERN.test(id),
+    providerError: id => `Security-review provider ${id} must be an object with review() or a factory`,
+    validateProvider: (provider, id) => {
+      assertSecurityReviewProviderIdentity(provider, { expectedId: id });
+      assertSecurityReviewProvider(provider, { label: `security-review provider "${id}"` });
+    },
+  });
+}
+
 export function createForgeLoopContext(options = {}) {
   const authorityContext = createAuthorityContext(options);
   const context = { authorityContext };
@@ -98,70 +206,19 @@ export function createForgeLoopContext(options = {}) {
     context.verificationExecutionPolicy = normalizeVerificationExecutionPolicy(options.verificationExecutionPolicy);
   }
   if (options?.usageProvider !== undefined) {
-    if (!options.usageProvider
-      || typeof options.usageProvider !== "object"
-      || Array.isArray(options.usageProvider)
-      || typeof options.usageProvider.getTaskUsage !== "function") {
-      const error = new Error("Usage provider must expose getTaskUsage({ projectPath, taskId })");
-      error.code = "E_USAGE_INVALID";
-      throw error;
-    }
-    context.usageProvider = options.usageProvider;
+    configureUsageProvider(context, options.usageProvider);
   }
   if (options?.structuralQualityProviders !== undefined) {
-    const configured = options.structuralQualityProviders instanceof Map
-      ? Object.fromEntries(options.structuralQualityProviders.entries())
-      : options.structuralQualityProviders;
-    if (!configured || typeof configured !== "object" || Array.isArray(configured)) {
-      const error = new Error("structuralQualityProviders must be an object or Map");
-      error.code = "E_STRUCTURAL_QUALITY_PROVIDER_INVALID";
-      throw error;
-    }
-    const providers = {};
-    for (const [id, provider] of Object.entries(configured)) {
-      if (!STRUCTURAL_QUALITY_PROVIDER_ID_PATTERN.test(id) || id === "sentrux") {
-        const error = new Error(`Invalid or reserved structural-quality provider ID: ${id}`);
-        error.code = "E_STRUCTURAL_QUALITY_PROVIDER_INVALID";
-        throw error;
-      }
-      if (typeof provider !== "function"
-        && (!provider || typeof provider !== "object" || Array.isArray(provider))) {
-        const error = new Error(`Structural-quality provider ${id} must be an object or factory`);
-        error.code = "E_STRUCTURAL_QUALITY_PROVIDER_INVALID";
-        throw error;
-      }
-      providers[id] = provider;
-    }
-    context.structuralQualityProviders = Object.freeze(providers);
+    configureStructuralQualityProviders(context, options.structuralQualityProviders);
   }
   if (options?.advisoryContextProviders !== undefined) {
-    const configured = options.advisoryContextProviders instanceof Map
-      ? Object.fromEntries(options.advisoryContextProviders.entries())
-      : options.advisoryContextProviders;
-    if (!configured || typeof configured !== "object" || Array.isArray(configured)) {
-      const error = new Error("advisoryContextProviders must be an object or Map");
-      error.code = E_ADVISORY_CONTEXT_PROVIDER_INVALID;
-      throw error;
-    }
-    const providers = {};
-    for (const [id, provider] of Object.entries(configured)) {
-      if (!/^[a-z0-9][a-z0-9_-]*$/.test(id)) {
-        const error = new Error(`Invalid advisory-context provider ID: ${id}`);
-        error.code = E_ADVISORY_CONTEXT_PROVIDER_INVALID;
-        throw error;
-      }
-      if (typeof provider !== "function"
-        && (!provider || typeof provider !== "object" || Array.isArray(provider))) {
-        const error = new Error(`Advisory-context provider ${id} must be an object or factory`);
-        error.code = E_ADVISORY_CONTEXT_PROVIDER_INVALID;
-        throw error;
-      }
-      if (typeof provider !== "function") {
-        assertAdvisoryContextProviderIdentity(provider, id);
-      }
-      providers[id] = provider;
-    }
-    context.advisoryContextProviders = Object.freeze(providers);
+    configureAdvisoryContextProviders(context, options.advisoryContextProviders);
+  }
+  if (options?.browserVerificationProviders !== undefined) {
+    configureBrowserVerificationProviders(context, options.browserVerificationProviders);
+  }
+  if (options?.securityReviewProviders !== undefined) {
+    configureSecurityReviewProviders(context, options.securityReviewProviders);
   }
   return Object.freeze(context);
 }