@jinn-network/core 0.1.0 → 0.1.1-canary.7b188db5

package/dist/scrub/build.js

@@ -1,9 +1,17 @@
 import { ScrubPipeline } from './pipeline.js';
-import { keyPolicyStage } from './key-policy.js';
-import { openredactionStage } from './openredaction-stage.js';
-import { plainPatternsStage } from './plain-patterns-stage.js';
-import { secretlintStage } from './secretlint-stage.js';
-import { mlPiiStage } from './ml-pii-stage.js';
+import { keyPolicyDetector } from './key-policy.js';
+import { plainPatternsDetector } from './plain-patterns-stage.js';
+import { gitIdentityDetector } from './git-identity-detector.js';
+import { secretlintDetector } from './secretlint-stage.js';
+import { mlPiiDetector } from './ml-pii-stage.js';
+import { assembleKnownIdentity, knownIdentityDetector, } from './known-identity-detector.js';
+import { urlCredentialsDetector } from './url-credentials-detector.js';
+import { rejectClassesDetector } from './reject-classes-detector.js';
+import { checksummedInstrumentsDetector } from './checksummed-instruments-detector.js';
+import { ipAddressDetector } from './ip-address-detector.js';
+import { gitleaksDetector } from './gitleaks-detector.js';
+import { DEFAULT_POLICY } from './policy.js';
+import { computeAllowlistDigest } from './provenance.js';
 /**
  * Default key policy. `jinn.*` identity/chain attributes are structural and pass
  * raw. The `drop` tier deletes the spec's stage-1 high-confidence keys outright
@@ -11,8 +19,9 @@ import { mlPiiStage } from './ml-pii-stage.js';
  * these never carry sellable content and are never safe to publish. Globs use the
  * trailing-`*` prefix form `classifyKey` supports; the HTTP header keys are listed
  * per request/response direction (a leading `*.header.…` glob is not matched, so
- * we enumerate the concrete keys). Everything else is `content` and flows through
- * the value-scrubbing stages.
+ * we enumerate the concrete keys). Machine-identity keys (D3 carrier) drop
+ * attempt-manifest `host` / hostname telemetry. Everything else is `content` and
+ * flows through the value-scrubbing detectors.
  */
 export const DEFAULT_KEY_POLICY = {
     safe: ['jinn.*'],
@@ -25,60 +34,110 @@ export const DEFAULT_KEY_POLICY = {
         'http.response.header.set-cookie',
         'env.*',
     ],
+    machineIdentity: [
+        'host',
+        'hostname',
+        'os.hostname',
+        'attempt.host',
+        'attempt.hostname',
+        'system.hostname',
+        'device.hostname',
+        'device.host',
+    ],
 };
+export function resolveKnownIdentity(opts) {
+    // AssembledKnownIdentity is a subset of AssembleKnownIdentityOptions;
+    // re-assembly is idempotent (allowlist entries are deduped).
+    return assembleKnownIdentity(opts);
+}
+/** Duck-type ML detector metadata for the policy hash (#1974). */
+function provenanceFromPiiDetector(detector) {
+    if (!detector)
+        return { modelId: null, labels: [] };
+    const withMeta = detector;
+    if (typeof withMeta.modelId === 'string' && withMeta.labelSet) {
+        return { modelId: withMeta.modelId, labels: withMeta.labelSet };
+    }
+    return { modelId: null, labels: [] };
+}
+/** Build provenance extras from known-identity + optional ML detector (#1974). */
+export function buildProvenanceExtras(knownIdentity, piiDetector) {
+    const ml = provenanceFromPiiDetector(piiDetector);
+    return {
+        modelId: ml.modelId,
+        labels: ml.labels,
+        allowlistDigest: computeAllowlistDigest(knownIdentity.allowlist.entries),
+    };
+}
+/**
+ * Shared detector inventory (#1969 / #1970 / #1971 / #1972 / #1973). Every
+ * publish/check consumer runs the same owned detectors (key-policy,
+ * plain-patterns including C1 wallet + A1 credential IDs, git-identity B2
+ * carriers, known-identity pack + non-address allowlist, Tier-1
+ * reject/URL/IP/instruments/gitleaks, secretlint). What varies is disposition /
+ * check-mode and whether an ML PII detector is injected. Seed keeps the entropy
+ * fallback off until A2 mid-band flags are absorbed without refuse-on-detection
+ * (#1409 shipped behavior). openredaction was retired in #1973.
+ */
+export function sharedDetectorInventory(policy, opts = {}) {
+    const detectors = [keyPolicyDetector(policy)];
+    detectors.push(plainPatternsDetector(policy));
+    detectors.push(gitIdentityDetector(policy));
+    detectors.push(knownIdentityDetector(policy, { assembled: resolveKnownIdentity(opts.knownIdentity) }));
+    detectors.push(urlCredentialsDetector(policy));
+    detectors.push(rejectClassesDetector(policy));
+    detectors.push(checksummedInstrumentsDetector(policy));
+    detectors.push(ipAddressDetector(policy));
+    detectors.push(gitleaksDetector(policy));
+    detectors.push(secretlintDetector(policy, { entropyFallback: opts.entropyFallback ?? true }));
+    if (opts.piiDetector) {
+        detectors.push(mlPiiDetector(policy, opts.piiDetector));
+    }
+    return detectors;
+}
 /**
- * Assembles the seller-side scrub pipeline (cost-ascending): structural key
- * policy → openredaction (structured PII) → secretlint + entropy (secrets) →
- * optional GLiNER (ML PII). The GLiNER stage is added only when a detector is
- * supplied, so the daemon degrades gracefully (regex + secrets still scrub) when
- * the ML model is unavailable.
+ * Trace / redact-mode preset over the shared inventory.
+ *
+ * @deprecated Prefer thinking in terms of one inventory + policy; this builder
+ * remains as a compatibility preset through the migration (#1969).
  */
 export function buildScrubPipeline(opts = {}) {
     const policy = opts.policy ?? DEFAULT_KEY_POLICY;
-    return new ScrubPipeline(assembleScrubStages(policy, opts.piiDetector));
-}
-function assembleScrubStages(policy, piiDetector) {
-    // plain-patterns runs after openredaction: deterministic email/home-path
-    // regexes closing gaps the probabilistic stage demonstrably has (#1330).
-    const stages = [
-        keyPolicyStage(policy),
-        openredactionStage(policy),
-        plainPatternsStage(policy),
-        secretlintStage(policy),
-    ];
-    if (piiDetector) {
-        stages.push(mlPiiStage(policy, piiDetector));
-    }
-    return stages;
+    const knownIdentity = resolveKnownIdentity(opts.knownIdentity);
+    return new ScrubPipeline(sharedDetectorInventory(policy, {
+        entropyFallback: true,
+        piiDetector: opts.piiDetector,
+        knownIdentity,
+    }), {
+        policy: DEFAULT_POLICY,
+        checkMode: false,
+        reviewStore: opts.reviewStore,
+        failClosedOnUnresolvedFlags: opts.failClosedOnUnresolvedFlags,
+        provenance: buildProvenanceExtras(knownIdentity, opts.piiDetector),
+    });
 }
 /**
- * Seed-profile scrub pipeline (#1409). Seeds are public, transformed or
- * otherwise human-curated content — not operator trace data — so the
- * probabilistic stages (openredaction, secretlint's pass-2 entropy fallback,
- * ML PII) that exist to catch unknown-shape PII/secrets in private traces are
- * dropped: on prose they false-positive (trigger words, dated env-var slugs,
- * long camelCase identifiers) and deface the corpus. The deterministic
- * detectors stay:
- * structural key policy, plain-patterns (emails, home paths, and — seed-only,
- * #1415 — bare AWS access-key IDs and GCP `AIza…` API keys, deterministic
- * prefix shapes secretlint pass-1 does not cover), and secretlint's pass-1
- * preset rules (AWS secret-key assignments, GitHub / Slack / npm token
- * shapes, GCP service-account JSON). Accepted residual: JWTs and unprefixed
- * high-entropy blobs (trace profile catches them via the entropy fallback),
- * plus every structured identifier or PII class detected only by the omitted
- * openredaction stage, pass unredacted. The latter is a 570+ pattern surface;
- * payment cards, phone numbers, SSNs, medical or health-plan identifiers,
- * government identity documents, and financial account references are
- * examples, not an exhaustive allowlist. This is acceptable only for public
- * seed material that a curator has transformed and reviewed for those classes.
- * The reduced stage list is inspectable locally through the pipeline's
- * `components` surface. `TraceEnvelopeV0` does not publish that list, so a
- * fetched envelope cannot by itself prove which scrub profile ran.
+ * Seed / redact-mode preset (#1409 / #1969). Same owned inventory as layer-2.
+ * Entropy fallback stays off to preserve the shipped zero-corruption seed
+ * behavior until A2 mid-band can flag without tripping refuse-on-detection.
+ *
+ * @deprecated Compatibility preset over the one inventory + policy table.
  */
-export function buildSeedScrubPipeline(policy = DEFAULT_KEY_POLICY) {
-    return new ScrubPipeline([
-        keyPolicyStage(policy),
-        plainPatternsStage(policy, { credentialIds: true }),
-        secretlintStage(policy, { entropyFallback: false }),
-    ]);
+export function buildSeedScrubPipeline(policyOrOpts = DEFAULT_KEY_POLICY) {
+    const opts = policyOrOpts && 'safe' in policyOrOpts
+        ? { policy: policyOrOpts }
+        : policyOrOpts;
+    const policy = opts.policy ?? DEFAULT_KEY_POLICY;
+    const knownIdentity = resolveKnownIdentity(opts.knownIdentity);
+    return new ScrubPipeline(sharedDetectorInventory(policy, {
+        entropyFallback: false,
+        piiDetector: opts.piiDetector,
+        knownIdentity,
+    }), {
+        policy: DEFAULT_POLICY,
+        checkMode: false,
+        reviewStore: opts.reviewStore,
+        failClosedOnUnresolvedFlags: opts.failClosedOnUnresolvedFlags,
+        provenance: buildProvenanceExtras(knownIdentity, opts.piiDetector),
+    });
 }

package/dist/scrub/checksummed-instruments-detector.d.ts

@@ -0,0 +1,13 @@
+/**
+ * B7 — checksummed payment instruments (#1972 / design §6.2).
+ *
+ * Card numbers (Luhn) and IBANs (mod-97). SSN-shape stays context-gated and is
+ * not emitted here.
+ */
+import { type KeyPolicy } from './key-policy.js';
+import type { Detector } from './finding.js';
+export declare function checksummedInstrumentsDetector(policy: KeyPolicy): Detector;
+/** ISO/IEC 7812 Luhn checksum. */
+export declare function luhnOk(digits: string): boolean;
+/** ISO 13616 IBAN mod-97 check. */
+export declare function ibanMod97Ok(iban: string): boolean;

package/dist/scrub/checksummed-instruments-detector.js

@@ -0,0 +1,119 @@
+/**
+ * B7 — checksummed payment instruments (#1972 / design §6.2).
+ *
+ * Card numbers (Luhn) and IBANs (mod-97). SSN-shape stays context-gated and is
+ * not emitted here.
+ */
+import { classifyKey } from './key-policy.js';
+const VERSION = '1.0.0';
+/** 13–19 digit runs, optional spaces/dashes between digit groups. */
+const CARD_CANDIDATE = /\b(?:\d[ -]*?){13,19}\b/g;
+/** IBAN: country + check digits + BBAN (no internal spaces in the candidate). */
+const IBAN_CANDIDATE = /\b[A-Z]{2}\d{2}[A-Z0-9]{11,30}\b/gi;
+/** Spaced IBAN groups (e.g. GB82 WEST 1234 5698 7654 32). */
+const IBAN_SPACED = /\b[A-Z]{2}\d{2}(?:[ ][A-Z0-9]{4}){2,7}(?:[ ][A-Z0-9]{1,4})?\b/gi;
+export function checksummedInstrumentsDetector(policy) {
+    const meta = { name: 'checksummed-instruments', version: VERSION };
+    return {
+        ...meta,
+        detect(attributes) {
+            const findings = [];
+            for (const [key, value] of Object.entries(attributes)) {
+                if (typeof value !== 'string' || classifyKey(key, policy) !== 'content')
+                    continue;
+                findings.push(...scanCards(value, key, meta));
+                findings.push(...scanIbans(value, key, meta));
+            }
+            return findings;
+        },
+    };
+}
+function scanCards(text, key, detector) {
+    const findings = [];
+    const re = new RegExp(CARD_CANDIDATE.source, CARD_CANDIDATE.flags);
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const raw = m[0];
+        const digits = raw.replace(/\D/g, '');
+        if (digits.length < 13 || digits.length > 19)
+            continue;
+        // Skip obvious non-cards (all same digit, leading zeros-only short ids).
+        if (/^(\d)\1+$/.test(digits))
+            continue;
+        if (!luhnOk(digits))
+            continue;
+        findings.push({
+            class: 'B7',
+            span: { key, start: m.index, end: m.index + raw.length },
+            confidence: 'VERY_HIGH',
+            evidence: ['card-luhn'],
+            detector,
+        });
+    }
+    return findings;
+}
+function scanIbans(text, key, detector) {
+    const findings = [];
+    const seen = new Set();
+    for (const pattern of [IBAN_CANDIDATE, IBAN_SPACED]) {
+        const re = new RegExp(pattern.source, pattern.flags);
+        let m;
+        while ((m = re.exec(text)) !== null) {
+            const raw = m[0];
+            const compact = raw.replace(/\s+/g, '').toUpperCase();
+            if (compact.length < 15 || compact.length > 34)
+                continue;
+            if (!ibanMod97Ok(compact))
+                continue;
+            const spanKey = `${m.index}:${m.index + raw.length}`;
+            if (seen.has(spanKey))
+                continue;
+            seen.add(spanKey);
+            findings.push({
+                class: 'B7',
+                span: { key, start: m.index, end: m.index + raw.length },
+                confidence: 'VERY_HIGH',
+                evidence: ['iban-mod97'],
+                detector,
+            });
+        }
+    }
+    return findings;
+}
+/** ISO/IEC 7812 Luhn checksum. */
+export function luhnOk(digits) {
+    let sum = 0;
+    let alt = false;
+    for (let i = digits.length - 1; i >= 0; i -= 1) {
+        let n = digits.charCodeAt(i) - 48;
+        if (n < 0 || n > 9)
+            return false;
+        if (alt) {
+            n *= 2;
+            if (n > 9)
+                n -= 9;
+        }
+        sum += n;
+        alt = !alt;
+    }
+    return sum % 10 === 0;
+}
+/** ISO 13616 IBAN mod-97 check. */
+export function ibanMod97Ok(iban) {
+    const rearranged = iban.slice(4) + iban.slice(0, 4);
+    let expanded = '';
+    for (const ch of rearranged) {
+        if (ch >= '0' && ch <= '9')
+            expanded += ch;
+        else if (ch >= 'A' && ch <= 'Z')
+            expanded += String(ch.charCodeAt(0) - 55);
+        else
+            return false;
+    }
+    // Progressive mod to avoid BigInt dependency for typical IBAN lengths.
+    let rest = 0;
+    for (const ch of expanded) {
+        rest = (rest * 10 + (ch.charCodeAt(0) - 48)) % 97;
+    }
+    return rest === 1;
+}

package/dist/scrub/data/bip39-english.d.ts

@@ -0,0 +1,2 @@
+/** BIP-39 English wordlist (2048 words). Vendored for A4 mnemonic detection. */
+export declare const BIP39_ENGLISH: readonly string[];