@quantakrypto/core 0.4.4 → 0.5.0

package/src/index.ts

@@ -56,13 +56,14 @@ export type {
 // Scan cancellation / work-budget errors.
 export { AbortError, BudgetExceededError } from "./errors.js";
 
-// Parallel scanning (worker_threads pool) + pure merge/chunk helpers.
-export { scanParallel, mergeChunkResults, chunkByBytes } from "./parallel.js";
-export type { ScanChunk, ChunkResult, SizedFile } from "./parallel.js";
+// Parallel scanning (worker_threads pool). The chunk/merge helpers and their
+// SizedFile/ChunkResult types are internal plumbing (not part of the public API).
+export { scanParallel } from "./parallel.js";
+export type { ScanChunk } from "./parallel.js";
 
-// Detector registry (plugin point) + helpers + the rule catalog.
-export { DetectorRegistry, defaultRegistry, detectorScope } from "./registry.js";
-export type { RuleCatalogEntry } from "./registry.js";
+// Detector registry (plugin point). `detectorScope` and the rule-catalog type are
+// internal.
+export { DetectorRegistry, defaultRegistry } from "./registry.js";
 
 // Canonical baseline (shared by qScan + the Action).
 export {
@@ -83,7 +84,7 @@ export { loadConfig, ConfigError, CONFIG_FILENAME } from "./config.js";
 export type { QuantakryptoFileConfig, LoadConfigResult } from "./config.js";
 
 // Filesystem walker (relative POSIX paths, default ignores, size/binary filters).
-export { walkFiles, isBinaryPath, isGeneratedPath, looksMinified } from "./walk.js";
+export { walkFiles, isBinaryPath, looksMinified } from "./walk.js";
 
 // Analyzable-language coverage (which source languages the scanner inspects).
 export {
@@ -104,7 +105,13 @@ export { vulnerableDependencies, DEP_VULNERABLE_RULE, isManifestFile } from "./d
 export { SEVERITY_ORDER, severityRank, meetsThreshold, sarifLevel } from "./severity.js";
 
 // Reporters.
-export { toSarif, toJson, formatSummary, formatTierGuidance } from "./report.js";
+export {
+  toSarif,
+  toJson,
+  formatSummary,
+  formatTierGuidance,
+  formatProfileGuidance,
+} from "./report.js";
 export type { ReportOptions } from "./report.js";
 
 // CycloneDX 1.6 cryptographic bill of materials (CBOM) export.
@@ -112,18 +119,29 @@ export { toCbom } from "./cbom.js";
 export type { CycloneDxBom, CbomComponent } from "./cbom.js";
 // Merge multiple CBOMs (code + infra + live endpoints) into one combined BOM.
 export { mergeCboms } from "./cbom-merge.js";
+// OpenVEX 0.2.0 export — quantum-readiness posture as VEX statements.
+export { toOpenVex } from "./vex.js";
+export type { OpenVexDocument, OpenVexStatement, OpenVexOptions } from "./vex.js";
 // ISO/IEC 27001 A.8.24 evidence-chain readiness report.
-export { buildReadinessReport } from "./evidence.js";
-export type { ReadinessReport, EvidenceFinding, ReadinessReportOptions } from "./evidence.js";
+export { buildReadinessReport, signReadinessReport, verifyReadinessReport } from "./evidence.js";
+export type {
+  ReadinessReport,
+  EvidenceFinding,
+  ReadinessReportOptions,
+  EvidenceSigner,
+  SignEvidenceOptions,
+  VerifyReadinessResult,
+} from "./evidence.js";
 
 // Cryptography policy → per-finding verdicts (A.8.24 evidence §4).
-export { buildPolicyMapping, parseCryptoPolicy, verdictForAlgorithm } from "./policy.js";
+export { buildPolicyMapping, parseCryptoPolicy } from "./policy.js";
 export type { CryptoPolicy, PolicyVerdict, PolicyMapping, PolicyFindingVerdict } from "./policy.js";
 
-// Remediation lookup (family + tier-aware) and stateful-HBS guidance.
+// Remediation lookup (family + tier-aware + profile-aware) and stateful-HBS guidance.
 export {
   remediationFor,
   remediationForTier,
+  remediationForProfile,
   TIER_PARAMS,
   STATEFUL_HBS_NOTE,
   PQC_TRANSITION_NOTE,
@@ -132,9 +150,19 @@ export {
 export type { SecurityTier } from "./remediation.js";
 
 // Post-quantum standards source of truth + review cadence.
-export { PQC_STANDARDS, standardsReviewStatus } from "./standards.js";
+export { PQC_STANDARDS } from "./standards.js";
 export type { PqcStandards, StandardsCitation, StandardsReviewStatus } from "./standards.js";
 
+// Selectable standards regime profiles (NIST / CNSA / BSI / ANSSI / NCSC).
+export {
+  STANDARDS_PROFILES,
+  DEFAULT_PROFILE_ID,
+  standardsProfileIds,
+  getStandardsProfile,
+  defaultStandardsProfile,
+} from "./standards-profiles.js";
+export type { StandardsProfile, HybridStance } from "./standards-profiles.js";
+
 // CWE identifier constants.
 export {
   CWE_BROKEN_CRYPTO,

package/src/inventory.ts

@@ -48,7 +48,7 @@ const SCORE_SCALE = 100;
 const TEST_PATH_WEIGHT = 0.15;
 
 /** True when a finding's file path is test / fixture / example / documentation. */
-export function isTestOrFixturePath(file: string): boolean {
+function isTestOrFixturePath(file: string): boolean {
   const f = file.toLowerCase().replace(/\\/g, "/");
   if (
     /(?:^|\/)(?:tests?|__tests__|testdata|test-data|fixtures?|examples?|demos?|samples?|specs?|mocks?|docs?|benchmarks?|e2e)\//.test(
@@ -75,20 +75,28 @@ export function isTestOrFixturePath(file: string): boolean {
 export function readinessScore(findings: Finding[]): number {
   if (findings.length === 0) return 100;
 
-  const seen: Record<Severity, number> = {
+  // Diminishing-returns occurrence counters, kept SEPARATE for full-weight vs
+  // test-path findings. Sharing one counter per severity let whichever finding came
+  // first in the (path-sorted) list claim the `1/√1` slot, so a directory rename — or
+  // a test finding sorting ahead of a real one — changed the score. Bucketing makes
+  // the penalty independent of file order and of test/real interleaving.
+  const zero = (): Record<Severity, number> => ({
     critical: 0,
     high: 0,
     medium: 0,
     low: 0,
     info: 0,
-  };
+  });
+  const seenReal = zero();
+  const seenTest = zero();
 
   let penalty = 0;
   for (const f of findings) {
-    seen[f.severity] += 1;
-    const weight =
-      SEVERITY_WEIGHT[f.severity] * (isTestOrFixturePath(f.location.file) ? TEST_PATH_WEIGHT : 1);
-    penalty += penaltyFor(weight, seen[f.severity]);
+    const isTest = isTestOrFixturePath(f.location.file);
+    const bucket = isTest ? seenTest : seenReal;
+    bucket[f.severity] += 1;
+    const weight = SEVERITY_WEIGHT[f.severity] * (isTest ? TEST_PATH_WEIGHT : 1);
+    penalty += penaltyFor(weight, bucket[f.severity]);
   }
 
   return Math.max(0, Math.min(100, Math.round(100 * Math.exp(-penalty / SCORE_SCALE))));

package/src/registry.ts

@@ -21,6 +21,10 @@ import { rubyDetector } from "./detectors/ruby.js";
 import { phpDetector } from "./detectors/php.js";
 import { elixirDetector } from "./detectors/elixir.js";
 import { cDetector } from "./detectors/c.js";
+import { swiftDetector } from "./detectors/swift.js";
+import { objcDetector } from "./detectors/objc.js";
+import { dartDetector } from "./detectors/dart.js";
+import { solidityDetector } from "./detectors/solidity.js";
 import { pemDetector } from "./detectors/pem.js";
 import { jwkDetector } from "./detectors/jwk.js";
 import { terraformDetector } from "./detectors/terraform.js";
@@ -31,10 +35,27 @@ import { joseDetector } from "./detectors/jose.js";
 import { k8sDetector } from "./detectors/k8s.js";
 import { messagingDetector } from "./detectors/messaging.js";
 import { databaseDetector } from "./detectors/database.js";
+import { xmldsigDetector } from "./detectors/xmldsig.js";
+import { pkcs11Detector } from "./detectors/pkcs11.js";
+import { dkimDetector } from "./detectors/dkim.js";
+import { sshCaDetector } from "./detectors/ssh-ca.js";
+import { spireDetector } from "./detectors/spire.js";
+import { proxyDetector } from "./detectors/proxy.js";
+import { webauthnDetector } from "./detectors/webauthn.js";
+import { codesignDetector } from "./detectors/codesign.js";
+import { weakHashDetector } from "./detectors/weak-hash.js";
 import { cloudformationDetector } from "./detectors/cloudformation.js";
+import { bicepDetector } from "./detectors/bicep.js";
+import { pulumiDetector } from "./detectors/pulumi.js";
 import { meshDetector } from "./detectors/mesh.js";
 import { dnssecDetector } from "./detectors/dnssec.js";
 import { vpnDetector } from "./detectors/vpn.js";
+import { ansibleDetector } from "./detectors/ansible.js";
+import { ageDetector } from "./detectors/age.js";
+import { supplyChainDetector } from "./detectors/supply-chain.js";
+import { vaultDetector } from "./detectors/vault.js";
+import { keystoreDetector } from "./detectors/keystore.js";
+import { openpgpDetector } from "./detectors/openpgp.js";
 import { statefulHbsDetector } from "./detectors/stateful-hbs.js";
 
 /** Normalised scope of a detector (defaults to "source" when undeclared). */
@@ -125,10 +146,15 @@ export class DetectorRegistry {
 }
 
 /**
- * The built-in detectors, in run order: the JS/TS source + config detectors,
- * then the per-language detectors (Python, Go, Java, C#, Rust, Ruby, C/C++),
- * then the language-agnostic PEM and stateful-HBS (SP 800-208) detectors. The
- * manifest (dependency) scanner is handled separately by `scan()`.
+ * The built-in detectors, in run order: the JS/TS source + language-agnostic config
+ * detectors, the per-language source packs (Python, Go, Java/Kotlin/Scala, C#, Rust,
+ * Ruby, PHP, Elixir, C/C++, Swift, Objective-C, Dart, Solidity/Move/Cairo), the
+ * infrastructure/config detectors (Terraform, Bicep, Pulumi, CloudFormation, cloud-KMS,
+ * k8s, mesh, DNSSEC, Vault, database/TDE, messaging, VPN, Ansible, supply-chain, CI/CD,
+ * secrets, age, keystore, OpenPGP, JWK, XML-DSig/SAML, PKCS#11/HSM, DKIM, SSH-CA,
+ * SPIFFE/SPIRE, reverse-proxy/gRPC TLS, WebAuthn/FIDO2, code-signing, weak-hash-in-
+ * signature), and the stateful-HBS (SP 800-208) detector. The manifest (dependency)
+ * scanner is handled separately by `scan()`.
  *
  * This is the single source of truth for the default detector set: both
  * {@link defaultRegistry} and the public `detectors` export (re-exported from
@@ -145,6 +171,10 @@ export const builtinDetectors: Detector[] = [
   phpDetector,
   elixirDetector,
   cDetector,
+  swiftDetector,
+  objcDetector,
+  dartDetector,
+  solidityDetector,
   pemDetector,
   jwkDetector,
   terraformDetector,
@@ -155,10 +185,27 @@ export const builtinDetectors: Detector[] = [
   k8sDetector,
   messagingDetector,
   databaseDetector,
+  xmldsigDetector,
+  pkcs11Detector,
+  dkimDetector,
+  sshCaDetector,
+  spireDetector,
+  proxyDetector,
+  webauthnDetector,
+  codesignDetector,
+  weakHashDetector,
   cloudformationDetector,
+  bicepDetector,
+  pulumiDetector,
   meshDetector,
   dnssecDetector,
   vpnDetector,
+  ansibleDetector,
+  ageDetector,
+  supplyChainDetector,
+  vaultDetector,
+  keystoreDetector,
+  openpgpDetector,
   statefulHbsDetector,
 ];
 

package/src/remediate-pipeline.ts

@@ -69,7 +69,7 @@ const NEW_SINK_LINE_RE = new RegExp(NEW_SINK_RE.source);
 
 /** Max changed lines allowed in an auto-verified LLM patch — a real crypto fix
  * is localized; a sprawling rewrite is not reviewable as "just the fix". */
-export const LLM_PATCH_MAX_CHANGED_LINES = 60;
+const LLM_PATCH_MAX_CHANGED_LINES = 60;
 
 function countMatches(re: RegExp, s: string): number {
   return (s.match(re) ?? []).length;

package/src/remediation.ts

@@ -6,6 +6,7 @@
  * standards to track are captured in {@link PQC_TRANSITION_NOTE}.
  */
 import type { AlgorithmFamily, Remediation } from "./types.js";
+import type { StandardsProfile } from "./standards-profiles.js";
 
 /** Canonical remediation table, keyed by algorithm family. */
 const REMEDIATIONS: Record<AlgorithmFamily, Remediation> = {
@@ -188,6 +189,44 @@ export function remediationForTier(
   };
 }
 
+/**
+ * Regime-aware remediation. Composes the base family guidance with a
+ * {@link StandardsProfile}'s parameter sets, HYBRID STANCE, and deprecation
+ * deadlines, so an ANSSI/BSI audience is told hybrid is *required* while a CNSA 2.0
+ * audience is told it is *optional* (and pointed at the 1024-level hybrid). This is
+ * the profile-driven successor to {@link remediationForTier}; `--tier category-5`
+ * resolves to the `cnsa-2.0` profile.
+ */
+export function remediationForProfile(
+  algorithm: AlgorithmFamily,
+  profile: StandardsProfile,
+): Remediation {
+  const base = REMEDIATIONS[algorithm];
+  const isConf = isConfidentialityFamily(algorithm);
+  const primary = isConf ? profile.paramSets.kem : profile.paramSets.signature;
+  // The hybrid stance governs KEY ESTABLISHMENT, so it is surfaced for confidentiality
+  // families; signature families migrate to a stateless PQC signer directly.
+  const stanceWord =
+    profile.hybridStance === "required"
+      ? "hybrid required"
+      : profile.hybridStance === "recommended"
+        ? "hybrid recommended"
+        : "hybrids optional";
+  const recommendation = isConf
+    ? `${primary} — ${profile.name}: ${stanceWord}`
+    : `${primary} — ${profile.name}`;
+  const hybridClause = isConf ? ` ${profile.hybridGuidance}` : "";
+  return {
+    algorithm,
+    recommendation,
+    detail:
+      `${base.detail} Under ${profile.name} (${profile.citation}), use ${profile.paramSets.kem} for ` +
+      `key establishment and ${profile.paramSets.signature} for signatures; classical public-key ` +
+      `crypto is deprecated after ${profile.deprecateAfter} and disallowed after ${profile.disallowAfter}.` +
+      hybridClause,
+  };
+}
+
 /**
  * Guidance for stateful hash-based signatures (SP 800-208: LMS / XMSS / HSS).
  * These are NIST-approved for firmware / boot signing but are STATEFUL — each

package/src/report.ts

@@ -7,8 +7,9 @@ import type { AlgorithmFamily, Finding, RuleMeta, ScanResult, Severity } from ".
 import { VERSION } from "./version.js";
 import { SEVERITY_ORDER, sarifLevel } from "./severity.js";
 import { ANALYZABLE_LANGUAGES_LABEL } from "./detect-utils.js";
-import { remediationFor, remediationForTier } from "./remediation.js";
+import { remediationFor, remediationForTier, remediationForProfile } from "./remediation.js";
 import type { SecurityTier } from "./remediation.js";
+import type { StandardsProfile } from "./standards-profiles.js";
 import { fingerprintFinding } from "./baseline.js";
 
 /** Minimal SARIF 2.1.0 log shape (kept permissive on purpose). */
@@ -475,3 +476,37 @@ export function formatTierGuidance(
   }
   return out;
 }
+
+/**
+ * Per-family migration targets tailored to a selected {@link StandardsProfile}
+ * (`--profile`). Unlike {@link formatTierGuidance} (CNSA-tier only), this surfaces the
+ * regime's parameter sets AND its hybrid stance — required (ANSSI/BSI) vs recommended
+ * (NIST/NCSC) vs optional (CNSA 2.0) — so guidance isn't regime-wrong. Returns plain
+ * (un-coloured) lines; the caller styles them.
+ */
+export function formatProfileGuidance(
+  byAlgorithm: Record<string, number>,
+  profile: StandardsProfile,
+): string[] {
+  const out: string[] = [`${profile.name} migration targets:`];
+  const seen = new Set<string>();
+  for (const [k, n] of Object.entries(byAlgorithm)) {
+    if (n <= 0) continue;
+    const fam = k as AlgorithmFamily;
+    if (fam === "unknown" || !remediationFor(fam)) continue; // skip unmapped families
+    const rem = remediationForProfile(fam, profile);
+    if (seen.has(rem.recommendation)) continue;
+    seen.add(rem.recommendation);
+    out.push(`  ${fam} → ${rem.recommendation}`);
+  }
+  const stance =
+    profile.hybridStance === "required"
+      ? "requires classical+PQC hybridization"
+      : profile.hybridStance === "recommended"
+        ? "recommends hybridization"
+        : "does not require hybridization";
+  out.push(
+    `  ${profile.authority} ${stance}; classical public-key crypto disallowed after ${profile.disallowAfter} (${profile.citation}).`,
+  );
+  return out;
+}

package/src/scan-worker.ts

@@ -15,7 +15,7 @@ import { parentPort, workerData } from "node:worker_threads";
 import type { Finding } from "./types.js";
 import { defaultRegistry } from "./registry.js";
 import { detectFile } from "./scan.js";
-import { looksMinified } from "./walk.js";
+import { isKeystorePath, looksMinified } from "./walk.js";
 import { isManifestFile } from "./dependencies.js";
 
 interface WorkerToggles {
@@ -48,14 +48,16 @@ if (parentPort) {
 
       for (const rel of req.files) {
         const abs = path.join(baseDir, ...rel.split("/"));
+        // Keystores (.jks/.p12/…) are read byte-preserving (latin1); see scan.ts.
+        const keystore = isKeystorePath(rel);
         let content: string;
         try {
-          content = readFileSync(abs, "utf8");
+          content = readFileSync(abs, keystore ? "latin1" : "utf8");
         } catch {
           unreadable += 1;
           continue;
         }
-        if (!toggles.scanMinified && !isManifestFile(rel) && looksMinified(content)) {
+        if (!toggles.scanMinified && !isManifestFile(rel) && !keystore && looksMinified(content)) {
           skippedMinified += 1;
           continue;
         }

package/src/scan.ts

@@ -13,7 +13,15 @@ import { readFile, stat } from "node:fs/promises";
 import * as path from "node:path";
 
 import type { Detector, Finding, ScanOptions, ScanResult } from "./types.js";
-import { walkFiles, toPosix, isBinaryPath, looksMinified, matchesAny } from "./walk.js";
+import {
+  walkFiles,
+  toPosix,
+  isBinaryPath,
+  isKeystorePath,
+  looksMinified,
+  matchesAny,
+  DEFAULT_MAX_FILE_SIZE,
+} from "./walk.js";
 import { isAnalyzableSource } from "./detect-utils.js";
 import {
   stripCommentFindings,
@@ -26,7 +34,16 @@ import {
  * A match inside a string (e.g. `t.Error("SigningMethodPS256 …")`) is prose and
  * is dropped. Rules that legitimately match quoted tokens are NOT listed here.
  */
-const CODE_ONLY_RULES: ReadonlySet<string> = new Set(["go-jwt-signingmethod"]);
+const CODE_ONLY_RULES: ReadonlySet<string> = new Set([
+  "go-jwt-signingmethod",
+  // Identifier-form JWT alg constants (jjwt `SignatureAlgorithm.RS256`, auth0
+  // `Algorithm.RSA256`, C# `SecurityAlgorithms.*`, Rust `Algorithm::RS256`). Like the
+  // Go rule, these are only meaningful as code; the SAME token inside a string literal
+  // (an error message that names/forbids the alg) is prose, not a usage.
+  "java-jwt-alg",
+  "csharp-jwt-alg",
+  "rust-jwt-algorithm",
+]);
 import { hashContent, loadCache, rulesetFingerprint, saveCache } from "./cache.js";
 import type { CacheEntry } from "./cache.js";
 import { builtinDetectors, defaultRegistry, detectorScope } from "./registry.js";
@@ -169,23 +186,41 @@ export async function scan(options: ScanOptions): Promise<ScanResult> {
 
     options.onFile?.(reportedPath);
 
+    // Cryptographic keystores (.jks/.p12/…) are binary; read them byte-preserving
+    // (latin1) so the keystore detector can inspect magic bytes.
+    const keystore = isKeystorePath(reportedPath);
+    // Keystores are read whole into memory as latin1. The walker already caps file
+    // size, but the explicit-file-list (incremental) path does not — so stat and
+    // skip an oversized binary here to avoid reading a huge encrypted archive
+    // (`.gpg`) into a string.
+    if (keystore) {
+      try {
+        const { size } = await stat(absPath);
+        if (size > (options.maxFileSize ?? DEFAULT_MAX_FILE_SIZE)) continue;
+      } catch {
+        unreadable += 1;
+        continue;
+      }
+    }
     let content: string;
     try {
-      content = await readFile(absPath, "utf8");
+      content = await readFile(absPath, keystore ? "latin1" : "utf8");
     } catch {
       unreadable += 1; // permissions / vanished / decode failure — tracked, not silent.
       continue;
     }
 
     // Skip machine-minified / generated content (unless explicitly enabled).
-    // Manifests are always scanned (their findings are dependency findings).
-    if (!scanMinified && !isManifestFile(reportedPath) && looksMinified(content)) {
+    // Manifests and keystores are always scanned.
+    if (!scanMinified && !isManifestFile(reportedPath) && !keystore && looksMinified(content)) {
       skippedMinified += 1;
       continue;
     }
 
     // Cumulative-byte budget: enforced once this file's bytes are accounted for.
-    bytesScanned += Buffer.byteLength(content, "utf8");
+    // Use the read encoding so a latin1 keystore is counted at its on-disk size
+    // (a utf8 byteLength would double-count every byte ≥ 0x80).
+    bytesScanned += Buffer.byteLength(content, keystore ? "latin1" : "utf8");
     if (typeof maxBytes === "number" && bytesScanned > maxBytes) {
       throw new BudgetExceededError(`maxBytes budget exceeded (limit: ${maxBytes}).`);
     }

package/src/standards-profiles.ts

@@ -0,0 +1,136 @@
+/**
+ * Selectable STANDARDS PROFILES — the regime a scan's remediation, deadlines, and
+ * hybrid guidance are tailored to. Different national/regional authorities agree on
+ * the PQC primitives (ML-KEM / ML-DSA) but diverge on two things this tool must not
+ * hardcode: (a) the required PARAMETER SETS (a commercial ML-KEM-768 vs a
+ * national-security ML-KEM-1024), and (b) the HYBRID STANCE — whether classical+PQC
+ * hybridization is required, recommended, or optional during the transition. Baking
+ * in NIST/CNSA's "hybrids optional" is wrong for an ANSSI or BSI audience, where
+ * hybrid is required. `--profile <id>` selects the regime; `--policy` composes an
+ * org's own exceptions on top.
+ *
+ * Like {@link PqcStandards}, every profile carries a citation + `asOf` date and is
+ * re-verified on the quarterly standards cadence. These are guidance summaries, not
+ * legal advice — consult the cited source of record.
+ */
+
+/** Whether classical+PQC hybridization is required during the transition, per regime. */
+export type HybridStance = "required" | "recommended" | "optional";
+
+/** A regime's PQC guidance profile. */
+export interface StandardsProfile {
+  /** Stable id used by `--profile` (kebab-case). */
+  readonly id: string;
+  /** Human-readable name. */
+  readonly name: string;
+  /** The authority / document of record. */
+  readonly authority: string;
+  /** The KEM / signature parameter sets this regime calls for. */
+  readonly paramSets: { readonly kem: string; readonly signature: string };
+  /** Whether hybridization is required / recommended / optional under this regime. */
+  readonly hybridStance: HybridStance;
+  /** One-line regime-specific hybrid guidance surfaced in remediation. */
+  readonly hybridGuidance: string;
+  /** Year after which classical public-key crypto is deprecated under this regime. */
+  readonly deprecateAfter: number;
+  /** Year after which it is disallowed. */
+  readonly disallowAfter: number;
+  /** Spec identifier / publication of record. */
+  readonly citation: string;
+  /** `YYYY-MM` — when this profile was last verified against its source. */
+  readonly asOf: string;
+}
+
+/** The default profile id when `--profile` is not given. */
+export const DEFAULT_PROFILE_ID = "nist";
+
+/**
+ * Built-in regime profiles. Facts reflect each authority's published PQC-transition
+ * position as of the `asOf` date; verify against the cited source before relying on a
+ * deadline or a hybrid mandate for a compliance decision.
+ */
+export const STANDARDS_PROFILES: Readonly<Record<string, StandardsProfile>> = {
+  nist: {
+    id: "nist",
+    name: "NIST (general / commercial)",
+    authority: "NIST",
+    paramSets: { kem: "ML-KEM-768 (FIPS 203)", signature: "ML-DSA-65 (FIPS 204)" },
+    hybridStance: "recommended",
+    hybridGuidance:
+      "Hybrid key establishment (e.g. X25519MLKEM768) is permitted and recommended during the transition; pure ML-KEM is also acceptable (SP 800-227 / IR 8547).",
+    deprecateAfter: 2030,
+    disallowAfter: 2035,
+    citation: "NIST IR 8547 + FIPS 203/204/205",
+    asOf: "2026-07",
+  },
+  "cnsa-2.0": {
+    id: "cnsa-2.0",
+    name: "NSA CNSA 2.0 (national-security systems)",
+    authority: "NSA",
+    paramSets: { kem: "ML-KEM-1024 (FIPS 203)", signature: "ML-DSA-87 (FIPS 204)" },
+    hybridStance: "optional",
+    hybridGuidance:
+      "CNSA 2.0 targets pure PQC and does not require hybrids; if a hybrid TLS group is used, it must be SecP384r1MLKEM1024 — X25519MLKEM768's ML-KEM-768 component is sub-CNSA.",
+    deprecateAfter: 2030,
+    disallowAfter: 2035,
+    citation: "NSA CNSA 2.0 (2030/2033/2035 migration milestones)",
+    asOf: "2026-07",
+  },
+  "bsi-tr-02102": {
+    id: "bsi-tr-02102",
+    name: "BSI TR-02102 (Germany)",
+    authority: "BSI",
+    paramSets: { kem: "ML-KEM-768 (FIPS 203)", signature: "ML-DSA-65 (FIPS 204)" },
+    hybridStance: "required",
+    hybridGuidance:
+      "BSI requires PQC be deployed in HYBRID with an established classical scheme during the transition (defense-in-depth); FrodoKEM is the conservative KEM alternative to ML-KEM, and XMSS/LMS are approved for firmware signing.",
+    deprecateAfter: 2030,
+    disallowAfter: 2035,
+    citation: "BSI TR-02102-1 (Kryptographische Verfahren)",
+    asOf: "2026-07",
+  },
+  anssi: {
+    id: "anssi",
+    name: "ANSSI (France)",
+    authority: "ANSSI",
+    paramSets: { kem: "ML-KEM-1024 (FIPS 203)", signature: "ML-DSA-87 (FIPS 204)" },
+    hybridStance: "required",
+    hybridGuidance:
+      "ANSSI requires HYBRIDIZATION (classical + PQC) throughout the transition phase and does not endorse pure PQC alone yet; use the highest parameter set for long-lived assurance.",
+    deprecateAfter: 2030,
+    disallowAfter: 2035,
+    citation: "ANSSI — PQC transition position papers",
+    asOf: "2026-07",
+  },
+  "uk-ncsc": {
+    id: "uk-ncsc",
+    name: "UK NCSC",
+    authority: "NCSC",
+    paramSets: { kem: "ML-KEM-768 (FIPS 203)", signature: "ML-DSA-65 (FIPS 204)" },
+    hybridStance: "recommended",
+    hybridGuidance:
+      "NCSC recommends ML-KEM / ML-DSA and is broadly agnostic on hybridization (recommended, not mandated); its migration milestones are earlier — discovery/plan by 2028, high-priority migration by 2031, complete by 2035.",
+    deprecateAfter: 2031,
+    disallowAfter: 2035,
+    citation: "NCSC — Preparing for quantum-safe cryptography / PQC migration timeline",
+    asOf: "2026-07",
+  },
+};
+
+/** All built-in profile ids, in a stable order (default first). */
+export function standardsProfileIds(): string[] {
+  return [
+    DEFAULT_PROFILE_ID,
+    ...Object.keys(STANDARDS_PROFILES).filter((id) => id !== DEFAULT_PROFILE_ID),
+  ];
+}
+
+/** Look up a built-in profile by id, or `undefined` when unknown. */
+export function getStandardsProfile(id: string): StandardsProfile | undefined {
+  return STANDARDS_PROFILES[id];
+}
+
+/** The default profile (NIST). Always defined. */
+export function defaultStandardsProfile(): StandardsProfile {
+  return STANDARDS_PROFILES[DEFAULT_PROFILE_ID];
+}

package/src/types.ts

@@ -137,6 +137,10 @@ export type DetectorLanguage =
   | "php"
   | "elixir"
   | "c"
+  | "swift"
+  | "objc"
+  | "dart"
+  | "solidity"
   | "any";
 
 /**
@@ -344,10 +348,11 @@ export interface ScanResult {
    */
   diagnostics?: ScanDiagnostics;
   /**
-   * Of `filesScanned`, how many were in a source language the scanner can
-   * actually analyze for inline crypto (JS/TS, Python, Go, Java). When this is 0 but
-   * `filesScanned` > 0, the readiness score reflects NO analyzable code — the
-   * crypto likely lives in an unsupported language (Go, Java, Rust, …) — and
+   * Of `filesScanned`, how many were in a source language the scanner can actually
+   * analyze for inline crypto (the 13 packs: JS/TS, Python, Go, Java/Kotlin/Scala,
+   * C#, Rust, Ruby, PHP, Elixir, C/C++, Swift, Objective-C, Dart). When this is 0
+   * but `filesScanned` > 0, the readiness score reflects NO analyzable code — the
+   * crypto likely lives in an unsupported language (Lua, Perl, …) — and
    * reporters surface that so a bare 100/100 can't read as "safe". Optional for
    * backward compatibility with hand-built results.
    */

package/src/version.ts

@@ -3,4 +3,4 @@
  * the scan orchestrator can import it without creating a cycle through index.ts.
  * Keep in sync with packages/core/package.json.
  */
-export const VERSION = "0.4.4";
+export const VERSION = "0.5.0";