@gate-forge/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,683 @@
+/**
+ * @gate-forge/core — the frozen public surface of the gateforge engine.
+ *
+ * STABILITY CONTRACT: every export here is a stable name. Later waves
+ * (graph, policy, verdict, baselines, waivers, reports, harness) add to
+ * this file; existing exports are never renamed or reshaped. Each export
+ * below is documented; if you need a new primitive, add it — do not
+ * repurpose an existing one.
+ *
+ * Layers:
+ * - canonical JSON + hashing (pin #1) — the substrate for ALL hashes
+ * - artifact schemas (zod) + inferred types — the frozen data ontology
+ *   (ADR 0001; pins #2-#6, #9, #11)
+ * - fingerprints (pin #2) — baseline identity
+ * - config loading (pin #6) — fail-closed `.gateforge.yml` handling
+ *
+ * @module @gate-forge/core
+ */
+/**
+ * Any JSON-representable value; the input domain of canonical hashing.
+ */
+export type { JsonValue } from './canonical-json.js';
+/**
+ * Type predicate narrowing an unknown value to {@link JsonValue}.
+ */
+export { isJsonValue } from './canonical-json.js';
+/**
+ * Serializes a value to GF-canonical-JSON (pin #1): UTF-8, recursively
+ * key-sorted, no whitespace, integers plain. Array order is preserved.
+ * Throws on NaN/Infinity (no canonical representation).
+ */
+export { canonicalJson } from './canonical-json.js';
+/**
+ * Lowercase hex sha256 of a string or byte buffer.
+ */
+export { sha256Hex } from './canonical-json.js';
+/**
+ * `sha256(canonicalJson(value))` — the single primitive behind
+ * fingerprints, GPP/3 digests, and witness record ids (pin #1).
+ */
+export { sha256Canonical } from './canonical-json.js';
+/**
+ * Derives the service-issued witness record id: sha256 over the
+ * GF-canonical JSON of `{runId, obligationId, kind, testId, origin,
+ * payload}`. The single source of truth shared by the witness
+ * (issuance) and every verifier (checking).
+ */
+export { recordIdOf, type RecordIdentity } from './provenance.js';
+/**
+ * Lenient provenance check (never throws): a record is provenanced only
+ * when its 64-hex recordId recomputes from its own contents. Records
+ * failing it demote to claimed tier (GF-23).
+ */
+export { isProvenancedRecord, isWitnessedRecord } from './provenance.js';
+/**
+ * Witness-ledger attestation (pin #7): HMAC-SHA256 over the canonical
+ * `{runId, recordIds}` set, keyed by the verifier key the tested suite
+ * never receives. Makes the suite-writable manifest append tamper-
+ * evident; `GET /ledger-attestation` serves the same authenticated set
+ * live.
+ */
+export { ledgerMac, verifyLedgerMac } from './provenance.js';
+/**
+ * V2 evidence attestation (plan §11.3): HMAC-SHA256 over the canonical
+ * `{domain: 'gateforge.ledger.v2', attestationVersion: 2, runId,
+ * invocationId, inputDigest, recordIds}` set, keyed by the verifier key
+ * the tested suite never receives. Binds issued evidence to the tested
+ * source/policy inputs and the fresh invocation identity. A legacy v1
+ * `{runId, recordIds}` MAC can never verify here (different signed
+ * bytes) and never authorizes evidence.
+ */
+export { ATTESTATION_DOMAIN, ATTESTATION_VERSION, attestationMac, verifyAttestationMac, type AttestationBody, } from './provenance.js';
+/**
+ * The only accepted `schemaVersion` on any artifact (currently `1`).
+ * Unknown versions are rejected everywhere; gateforge never migrates.
+ */
+export { GATEFORGE_SCHEMA_VERSION } from './schemas/common.js';
+/**
+ * Source location shape (file, 1-based line, 0-based col) used by
+ * unresolved reasons and detector provenance.
+ */
+export { LocationSchema } from './schemas/common.js';
+export type { Location } from './schemas/common.js';
+/** Contract-name grammar: interior colons legal (`crud:update`), no leading colon. */
+export { ContractNameSchema } from './schemas/common.js';
+/** Inferred contract-name type. */
+export type { ContractName } from './schemas/common.js';
+/** Exposure enum schema: `user-facing | internal`. */
+export { ExposureSchema } from './schemas/common.js';
+/** Inferred exposure type. */
+export type { Exposure } from './schemas/common.js';
+/** Plane enum schema: `tenant | master | global`. */
+export { PlaneSchema } from './schemas/common.js';
+/** Inferred plane type. */
+export type { Plane } from './schemas/common.js';
+/** Transport enum schema: `subprocess | in-process` (ADR 0002). */
+export { TransportSchema } from './schemas/common.js';
+/** Inferred transport type. */
+export type { Transport } from './schemas/common.js';
+/** Trust-tier enum schema: `claimed | witnessed` (ADR 0001). */
+export { TrustTierSchema } from './schemas/common.js';
+/** Inferred trust-tier type. */
+export type { TrustTier } from './schemas/common.js';
+/**
+ * Resource (plan §4.2): stable code-derived object discovered by a
+ * detector — id, kind, source, location, detector version, attributes.
+ */
+export { ResourceSchema } from './schemas/resource.js';
+/** Inferred resource type. */
+export type { Resource } from './schemas/resource.js';
+/**
+ * Classification (plan §4.3): exposure, plane, lifecycle, ordered
+ * `primaryKey`, evidence adapter. User-facing entries require an
+ * adapter; internal entries default to no CRUD obligations.
+ */
+export { ClassificationSchema, ClassificationFileSchema, LifecycleSchema } from './schemas/classification.js';
+/** Inferred per-resource classification type. */
+export type { Classification } from './schemas/classification.js';
+/** Inferred classifications-document type. */
+export type { ClassificationFile } from './schemas/classification.js';
+/** Inferred lifecycle type (create/read/update/delete + semantics). */
+export type { Lifecycle } from './schemas/classification.js';
+/**
+ * Policy (plan §4.4): declarative when/require mapping from resource
+ * attributes to required contracts. Pure data, no code escape hatch.
+ */
+export { PolicySchema, PolicyFileSchema, PolicyWhenSchema } from './schemas/policy.js';
+/** Inferred single-policy type. */
+export type { Policy } from './schemas/policy.js';
+/** Inferred policies-document type. */
+export type { PolicyFile } from './schemas/policy.js';
+/** Inferred policy-matcher type. */
+export type { PolicyWhen } from './schemas/policy.js';
+/**
+ * Obligation (plan §4.5): `<resourceId>:<contract>` requirement with
+ * policyId and relevant lifecycle (fingerprint identity inputs).
+ */
+export { ObligationSchema } from './schemas/obligation.js';
+/** Inferred obligation type. */
+export type { Obligation } from './schemas/obligation.js';
+/**
+ * Claim (plan §4.6): a test's declared coverage of one obligation via
+ * native framework metadata. Claims are not proof.
+ */
+export { ClaimSchema, ObligationIdSchema } from './schemas/claim.js';
+/** Inferred claim type. */
+export type { Claim } from './schemas/claim.js';
+/** Inferred `<resourceId>:<contract>` id type. */
+export type { ObligationId } from './schemas/claim.js';
+/**
+ * EvidenceRecord (plan §4.7, pins #7/#11): witness-issued trusted
+ * record — recordId, runId, trust tier, obligation, kind, optional
+ * bulk scope. Only `witnessed` can satisfy (GF-23).
+ */
+export { EvidenceRecordSchema, BulkScopeSchema, RecordOriginSchema, type RecordOrigin, } from './schemas/evidence.js';
+/** Inferred evidence-record type. */
+export type { EvidenceRecord } from './schemas/evidence.js';
+/** Inferred bulk-scope type (pin #11). */
+export type { BulkScope } from './schemas/evidence.js';
+/**
+ * Waiver (ADR 0001): ALL FIVE mandatory fields — owner,
+ * justificationUrl, approver, exact scope (resourceId + fingerprint),
+ * expiresAt. Missing any = config error. Expiry ⇒ `invalid`, not
+ * `waived`.
+ */
+export { WaiverSchema, WaiverScopeSchema } from './schemas/waiver.js';
+/** Inferred waiver type. */
+export type { Waiver } from './schemas/waiver.js';
+/** Inferred waiver-scope type. */
+export type { WaiverScope } from './schemas/waiver.js';
+/**
+ * Baseline (pin #3): `.gateforge/baselines/obligations.json` —
+ * `{schemaVersion, fingerprints}` with a sorted, duplicate-free list.
+ */
+export { BaselineSchema, FingerprintHexSchema } from './schemas/baseline.js';
+/** Inferred baseline-document type. */
+export type { Baseline } from './schemas/baseline.js';
+/** Inferred fingerprint-hex string type. */
+export type { FingerprintHex } from './schemas/baseline.js';
+/**
+ * RunManifest (pin #4): runId, injected-clock startedAt, gitSha (or
+ * null), provider, plugin set, attestationScope. Every verdict and
+ * witnessed record references its run.
+ */
+export { RunManifestSchema, ChangedProviderSchema, AttestationSchema } from './schemas/run-manifest.js';
+/** Inferred run-manifest type. */
+export type { RunManifest, Attestation } from './schemas/run-manifest.js';
+/** Inferred changed-provider type. */
+export type { ChangedProvider } from './schemas/run-manifest.js';
+/**
+ * Verdict (ADR 0001): the seven verdicts — satisfied, missing, invalid,
+ * unclassified, unresolved, waived, stale. Blocking verdicts are all
+ * except `satisfied` and `waived`.
+ */
+export { VerdictSchema } from './schemas/verdict.js';
+/** Inferred verdict union type. */
+export type { Verdict } from './schemas/verdict.js';
+/**
+ * CauseCode (plan 2026-09-13 §5.4, ADR 0005): stable blocking-obligation
+ * cause codes plus the three advisory `DIAGNOSTIC_*` result causes. The
+ * seven verdict VALUES are unchanged; causes enrich the shared report
+ * model (text, JSON, and SARIF all carry them).
+ */
+export { CauseCodeSchema, CAUSE_NEXT_ACTIONS } from './schemas/verdict.js';
+/** Inferred cause-code union type. */
+export type { CauseCode } from './schemas/verdict.js';
+/**
+ * CoveragePolicy (plan 2026-09-13 §3.6, ADR 0005 D5): the tracked,
+ * owner-owned `coveragePolicy` config section — user-facing tables,
+ * required real-UI operations, and owner dispositions. Absent/empty =
+ * feature off (opt-in); agent edits never self-approve a disposition.
+ */
+export { COVERAGE_OPERATIONS, CoverageOperationSchema, CoveragePolicySchema, CoverageTableSchema, CoverageDispositionSchema, } from './schemas/coverage-policy.js';
+/** Inferred coverage-policy types. */
+export type { CoverageOperation, CoveragePolicy, CoverageTable, CoverageDisposition, } from './schemas/coverage-policy.js';
+/**
+ * UnresolvedReason (pin #5): `{code, detail, location{file,line,col}}` —
+ * single-cause, machine-readable, no stack dumps.
+ */
+export { UnresolvedReasonSchema } from './schemas/verdict.js';
+/** Inferred unresolved-reason type. */
+export type { UnresolvedReason } from './schemas/verdict.js';
+/**
+ * TestCatalog (plan 2026-09-13 §5.1 row 1 + §5.2): the derived inventory
+ * of a repository's existing tests. Logical keys are the stable mapping
+ * identity (line numbers are diagnostics); duplicate keys are a typed
+ * parse error listing both sources; unresolved rows are first-class data
+ * so a failed scan is never misread as "no tests".
+ */
+export { SUPPORTED_TEST_RUNNERS, TestRunnerSchema, TestKindSchema, DiscoveryStatusSchema, ReconciliationStatusSchema, RuleEvidenceSchema, KindSignalSchema, WeakSignalSchema, CategorySignalSchema, SuppressionSignalKindSchema, SuppressionSignalSchema, TestCatalogEntrySchema, CatalogParseErrorSchema, RunnerSummarySchema, TestCatalogSchema, deriveLogicalKey, } from './schemas/test-catalog.js';
+/** Inferred test-catalog types. */
+export type { TestRunner, TestKind, DiscoveryStatus, ReconciliationStatus, RuleEvidence, KindSignal, WeakSignal, CategorySignal, SuppressionSignalKind, SuppressionSignal, TestCatalogEntry, CatalogParseError, RunnerSummary, TestCatalog, CatalogUnresolved, } from './schemas/test-catalog.js';
+/**
+ * Runner-adapter contract (plan 2026-09-13 phase 2 item 6): the small
+ * interface every test-runner adapter implements. Types only — adapters
+ * live in their packs; capabilities are declared, never implied.
+ */
+export type { RunnerCapability, RunnerCapabilities, RunnerTestInstance, RunnerSelection, RunnerExecutionEnv, RunnerInstanceOutcome, RunnerExecutionEnvelope, TestRunnerAdapter, } from './schemas/runner-adapter.js';
+/**
+ * PluginRegistration: pinned plugin identity `{id, version, transport}`
+ * shared by run manifests (pin #4) and the GPP/3 handshake (pin #5).
+ */
+export { PluginRegistrationSchema } from './schemas/plugin.js';
+/** Inferred plugin-registration type. */
+export type { PluginRegistration } from './schemas/plugin.js';
+/**
+ * Obligation fingerprint (pin #2):
+ * `sha256(canonical({resourceId, contract, policyId, lifecycle}))`.
+ * Key-order independent; this is the identity baselines store.
+ */
+export { fingerprint, FingerprintInputSchema } from './fingerprints.js';
+/** Blocking-entry fingerprint (phase 8 C): baseline identity for gate red
+ * that is not an obligation (findings, unclassified, stale references). */
+export { blockingEntryFingerprint } from './fingerprints.js';
+/** Inferred fingerprint-input type. */
+export type { FingerprintInput } from './fingerprints.js';
+/**
+ * `.gateforge.yml` document schema (pin #6): project paths, plugins,
+ * policies/classifications/adapters/waivers/baselines paths, changed
+ * provider, witness bounds, clock mode, optional enforcement modes, and
+ * optional coverage policy. Unknown keys and unknown schemaVersion are
+ * rejected.
+ */
+export { GateforgeConfigSchema, ConfigPluginSchema, EnforcementConfigSchema } from './config/index.js';
+/** Inferred `.gateforge.yml` type. */
+export type { GateforgeConfig } from './config/index.js';
+/** Inferred config-plugin-entry type. */
+export type { ConfigPlugin } from './config/index.js';
+/** Inferred enforcement-section type (mode + strictE2E; off by default). */
+export type { EnforcementConfig } from './config/index.js';
+/**
+ * Diagnostics config (plan 2026-09-13 §3.5): explicitly registered
+ * diagnostic suites (pytest today). Absent = feature off; gateforge
+ * never scans for or launches unregistered suites.
+ */
+export { DiagnosticsConfigSchema, DiagnosticSuiteSchema } from './config/index.js';
+/** Inferred diagnostics-section type. */
+export type { DiagnosticsConfig, DiagnosticSuite } from './config/index.js';
+/** One actionable config diagnostic (file, jsonPath, expected vs got). */
+export type { ConfigDiagnostic } from './config/index.js';
+/** Error for any fail-closed config problem; carries `.diagnostics`. */
+export { GateforgeConfigError } from './config/index.js';
+/**
+ * Validates an already-parsed config document; throws
+ * {@link GateforgeConfigError} with actionable diagnostics on failure.
+ */
+export { parseConfig } from './config/index.js';
+/**
+ * Loads and validates `.gateforge.yml` from disk (default
+ * `.gateforge.yml` in cwd); fail-closed on missing/unparsable/invalid.
+ */
+export { loadConfig } from './config/index.js';
+/**
+ * Diagnostics helpers: `diagnosticsFromZodError` converts zod issues,
+ * `jsonPathFor` renders JSON paths, `formatDiagnostics` renders the
+ * human-readable multi-line listing used in error messages.
+ */
+export { diagnosticsFromZodError, jsonPathFor, formatDiagnostics } from './config/index.js';
+/**
+ * Detector finding (discovery-spike lineage, e.g.
+ * `DUPLICATE_TABLE_NAME`): a non-resource observation about scanned
+ * sources. Canonical home of the shape; the plugin protocol carries a
+ * wire-compatible copy.
+ */
+export { FindingSchema } from './graph/index.js';
+/** Inferred finding type. */
+export type { Finding } from './graph/index.js';
+/**
+ * Finding with detector provenance: graph-issued findings carry
+ * detectorId `gateforge.graph`.
+ */
+export { GraphFindingSchema } from './graph/index.js';
+/** Inferred graph-finding type. */
+export type { GraphFinding } from './graph/index.js';
+/**
+ * One detector's contribution: pinned identity (pluginId + version)
+ * plus the pinned discovery shape (`resources`, `unresolved`,
+ * `findings`).
+ */
+export { DetectorOutputSchema } from './graph/index.js';
+/** Inferred detector-contribution type. */
+export type { DetectorOutput } from './graph/index.js';
+/** Reserved resource `kind` for symbol-table class declarations. */
+export { CLASS_SYMBOL_KIND, EVIDENCE_ONLY_RESOURCE_KINDS, HTTP_ENDPOINT_RESOURCE_KIND, isEvidenceOnlyKind } from './graph/index.js';
+/** Attribute payload of a class-symbol resource. */
+export { ClassSymbolAttributesSchema } from './graph/index.js';
+/** Inferred class-symbol attribute type. */
+export type { ClassSymbolAttributes } from './graph/index.js';
+/** Canonical detector attribute carrying a resource's identity name. */
+export { RESOURCE_NAME_ATTRIBUTE } from './graph/index.js';
+/**
+ * Normalized graph resource: plane-qualified `plane.name` id (D5.3),
+ * repo-root-relative source, bound classification (or `null` while
+ * unclassified), and detector provenance.
+ */
+export { GraphResourceSchema } from './graph/index.js';
+/** Inferred normalized-resource type. */
+export type { GraphResource } from './graph/index.js';
+/** Gate-visible unresolved entry with detector provenance. */
+export { GraphUnresolvedSchema } from './graph/index.js';
+/** Inferred graph-unresolved type. */
+export type { GraphUnresolved } from './graph/index.js';
+/** A reference to a removed/renamed resource (invariant 9, GF-06). */
+export { StaleReferenceSchema, StaleReferenceKindSchema } from './graph/index.js';
+/** Inferred stale-reference type. */
+export type { StaleReference } from './graph/index.js';
+/** Inferred stale-reference-kind type. */
+export type { StaleReferenceKind } from './graph/index.js';
+/** Inferred resource-graph input type (detectors + watched artifacts). */
+export type { ResourceGraphInput } from './graph/index.js';
+/** The built resource graph: deterministic, fully sorted. */
+export { ResourceGraphSchema } from './graph/index.js';
+/** Inferred resource-graph type. */
+export type { ResourceGraph } from './graph/index.js';
+/**
+ * Builds the resource graph from detector contributions +
+ * classifications + watched claim/adapter/waiver populations. Pure:
+ * same inputs → identical graph byte-for-byte. Throws (fail closed)
+ * on an invalid classifications document.
+ */
+export { buildResourceGraph } from './graph/index.js';
+/** The repo-wide class-symbol table and base-chain resolution. */
+export { buildSymbolTable, resolveInheritedName, sortUnresolved } from './graph/index.js';
+/** Inferred class-symbol type. */
+export type { ClassSymbol } from './graph/index.js';
+/** Inferred inheritance-resolution outcome type. */
+export type { InheritanceResolution } from './graph/index.js';
+/** Codepoint-wise deterministic comparison helpers (never localeCompare). */
+export { compareStrings, compareLocations } from './graph/index.js';
+/**
+ * ClassificationSignal (ADR 0003 D1): a source-located, detector-
+ * versioned FACT a detector emits about one classification dimension.
+ * Signals carry a `basis`, never a confidence score; only
+ * `code-negative-closed-world` can ever suppress, and only over a
+ * complete scan.
+ */
+export { ClassificationSignalSchema, signalId, SignalTargetSchema, SignalDimensionSchema, SignalBasisSchema, SignalAssertionSchema, SIGNAL_DIMENSIONS } from './schemas/classification-signal.js';
+/** Inferred classification-signal type. */
+export type { ClassificationSignal, SignalTarget, SignalDimension, SignalBasis, SignalAssertion } from './schemas/classification-signal.js';
+/**
+ * ClassificationPolicy: the `classification-policy.yml` document —
+ * scan roots, trusted internal entry-point categories, organization
+ * internal rules (certificate inputs, never overrides), supported
+ * declaration syntax, and volatile fields.
+ */
+export { ClassificationPolicySchema, InternalEntryPointCategorySchema, InternalRuleSchema, InternalRuleMatchSchema, } from './schemas/classification-policy.js';
+/** Inferred classification-policy type. */
+export type { ClassificationPolicy, InternalEntryPointCategory, InternalRule, InternalRuleMatch } from './schemas/classification-policy.js';
+/**
+ * The deterministic conservative classifier (ADR 0003 D2):
+ * `classifyResources()` resolves signals into effective classifications
+ * or typed machine-actionable blocks; uncertainty adds obligations and
+ * never removes them.
+ */
+export { RULES, classifyResources, ClassifierBlockSchema, ClassifierBlockCodeSchema, CLASSIFIER_BLOCK_CODES, BLOCK_DIMENSIONS, ClassifierContradictionSchema, ClassificationDecisionTraceSchema, EffectiveClassificationSchema, compileGlob, globMatch, pathInScope, classifierBlocking, resourceRef, runClassification, } from './classifier/index.js';
+/** Inferred classifier types. */
+export type { ClassifierResourceRef, ClassificationDecision, ClassificationResult, ClassifierScanInput, ClassifyResourcesInput, ClassifierBlock, ClassifierBlockCode, ClassifierContradiction, ClassificationDecisionTrace, EffectiveClassification, } from './classifier/index.js';
+/** The lifecycle-gated CRUD contract namespace (`crud:create`, …). */
+export { CRUD_CONTRACT_PREFIX } from './policy/index.js';
+/**
+ * Why a resource currently generates no obligations: `unclassified` or
+ * `unresolved` — gate-visible blocking entries (invariants 1, 8).
+ */
+export { BlockingEntrySchema } from './policy/index.js';
+/** Inferred blocking-entry type. */
+export type { BlockingEntry } from './policy/index.js';
+/**
+ * The adopted identity of a classification-blocked resource (two-layer
+ * adoption) — the canonical string `adopt` records and `check` matches.
+ */
+export { classificationBlockedIdentity } from './policy/index.js';
+/** Assessment of one claim against the generated obligations. */
+export { ClaimAssessmentSchema } from './policy/index.js';
+/** Inferred claim-assessment type. */
+export type { ClaimAssessment } from './policy/index.js';
+/** The complete policy-engine result: obligations + blocking + claims. */
+export { PolicyEvaluationResultSchema } from './policy/index.js';
+/** Inferred policy-evaluation-result type. */
+export type { PolicyEvaluationResult } from './policy/index.js';
+/** Fail-closed policy-engine error (invalid policy document / contract). */
+export { PolicyEvaluationError } from './policy/index.js';
+/**
+ * Evaluates policies against a built graph: lifecycle-gated obligation
+ * generation (plan §5.2), no CRUD obligations for internal resources
+ * (ADR 0001), blocking entries for unclassified/unresolved resources,
+ * and claim assessment. Pure; deterministic.
+ */
+export { evaluatePolicies, lifecycleAllowsContract } from './policy/index.js';
+/**
+ * Closed-world CRUD coverage evaluator (plan 2026-09-13 §3.6, ADR 0005
+ * D5): pure; returns typed blocking `CRUD_COVERAGE_MISSING` findings per
+ * uncovered/undispositioned required operation and CONFIG-ERROR results
+ * for policy tables absent from the caller-provided resource inventory.
+ */
+export { evaluateCoveragePolicy } from './policy/index.js';
+/** Coverage-evaluator input/result types. */
+export type { CoverageInventoryTable, MappedCoverage, CoverageConfigError, CoverageBlockingFinding, CoveragePolicyResult, } from './policy/index.js';
+/**
+ * Protected policy ownership foundation (plan 2026-09-13 Phase 0 item 5,
+ * ADR 0005 D6): the domain-separated trusted policy/config digest for
+ * later receipt binding, plus the pure weakening check — a candidate
+ * whose policy revision differs from the trusted one is a weakening
+ * candidate until a separate trusted update is accepted. Enforcement
+ * lands in Phases 4-5.
+ */
+export { TRUSTED_POLICY_DOMAIN, trustedPolicyDigest, policyWeakenedCandidate } from './policy/index.js';
+/** Trusted-policy ownership types. */
+export type { TrustedPolicyInput, PolicyWeakeningCheck } from './policy/index.js';
+/**
+ * Evaluates ONE obligation against claims, records, waivers,
+ * classification, and the injected clock: pure `evaluateObligation(
+ * obligation, {claims, records, waivers, classification, now})`
+ * → `{verdict, reason, recordIds}` (pin #9). `satisfied` requires
+ * complete witnessed evidence (D2, GF-23); same-entity enforcement is
+ * column-keyed for composite identity (D3); expired waivers yield
+ * `invalid` (D4).
+ */
+export { evaluateObligation } from './verdict/index.js';
+/**
+ * Batch wrapper: evaluates obligations against one context and returns
+ * report-ready entries (obligation + verdict + trustTier), sorted by
+ * obligation id.
+ */
+export { evaluateObligations } from './verdict/index.js';
+/** The five gate-blocking verdicts (`satisfied`/`waived` are clean). */
+export { BLOCKING_VERDICTS } from './verdict/index.js';
+export { registerContractVerifier, verifierFor, registeredNamespaces, type ClaimEvidenceInput, type ClaimOutcome, type ContractVerifier, type HttpRouteCandidate, } from './verdict/index.js';
+/**
+ * Verifier capability metadata (plan 2026-09-13 Phase 0 item 3, ADR
+ * 0005): the single source of truth for what each contract namespace can
+ * honestly prove, its required observer channel, supported test kinds,
+ * and availability. First-wins/no-override, like verifier registration.
+ */
+export { registerContractCapabilities, capabilityFor, allCapabilities, type ContractCapability, type ContractAvailability, } from './verdict/index.js';
+/**
+ * Cause mapping + strict preflight (plan 2026-09-13 §5.4 / Phase 0 item
+ * 4): derives stable cause codes and next actions for blocking verdicts,
+ * and computes the precise capability gaps a strict setup fails closed
+ * on (VERIFIER_UNSUPPORTED).
+ */
+export { causeForVerdict, capabilityGap, strictCapabilityGaps, type VerdictCause, type CapabilityGap, } from './verdict/index.js';
+/**
+ * Deterministic runtime route attribution (plan §9, D2): the single
+ * path interpretation plus the complete-inventory resolver the HTTP
+ * transport verifier grades against. No literal-precedence shortcut;
+ * ambiguity blocks.
+ */
+export { interpretObservedPath, resolveHttpRoute, pathMatchesShape } from './verdict/index.js';
+/** Fail-closed verdict-engine error (malformed obligation / clock). */
+export { GateforgeVerdictError } from './verdict/index.js';
+/** Normalizes the injected clock (`Date | string`) to a `Date`. */
+export { parseInstant } from './verdict/index.js';
+/** The pinned pin-#9 result shape: `{verdict, reason, recordIds}`. */
+export type { VerdictOutcome } from './verdict/index.js';
+/** Report-ready per-obligation verdict (adds obligation + trustTier). */
+export type { ObligationVerdict } from './verdict/index.js';
+/** The pin-#9 evaluation context. */
+export type { VerdictContext } from './verdict/index.js';
+/** A waiver plus the engine-only `ownerStale` flag (GF-17). */
+export type { WaiverRef } from './verdict/index.js';
+/**
+ * TestMap (plan 2026-09-13 §5.3): the versioned `.gateforge/test-map.yml`
+ * sidecar an agent (or `tests mark`) writes to connect an EXISTING test
+ * to obligations without rewriting a test body. Claims non-empty, kind a
+ * supported TestKind, reason required, duplicate keys rejected naming
+ * both entries; `'*'` wildcards never parse (not obligation ids).
+ */
+export { TestMapSchema, TestMapEntrySchema, TestSelectorSchema } from './schemas/test-map.js';
+/** Inferred test-map types. */
+export type { TestMap, TestMapEntry, TestSelector } from './schemas/test-map.js';
+/**
+ * The ONE mapping resolver (plan §5.3, Phase 3): normalizes native
+ * claims, sidecar declarations, prior-run hints, and inference into one
+ * resolved surface. Deterministic; contradictions/staleness become typed
+ * problems naming both locations; inference never auto-writes a mapping;
+ * projections into grading claims carry intent only — no evidence — so a
+ * mapped-but-unexecuted obligation still blocks.
+ */
+export { resolveTestMappings, mappingSuggestions, mappingGradingClaims, } from './mapping/resolve.js';
+/** Inferred mapping-resolver types. */
+export type { ResolveMappingsInput, ResolvedMappings, ObligationBindings, ResolvedClaimBinding, MappingProblem, MappingProblemCause, MappingOrigin, TestInstanceRef, PriorRunHint, MappingSuggestionsInput, MappingSuggestion, MappingSuggestionCause, SuggestionCandidate, } from './mapping/resolve.js';
+/**
+ * Execution result (plan 2026-09-13 §5.1, ADR 0005 D2, Phase 4): the
+ * trusted supervisor's sealed run record — planned versus executed
+ * instances, outcomes/attempts, runner exit, fixture/teardown outcome,
+ * shard completeness, selection + catalog digests, engines, and
+ * environment identity — plus the domain-separated selection digest.
+ * Reporter data is input here, never signature authority.
+ */
+export { EXECUTION_RESULT_DOMAIN, SELECTION_DOMAIN, ExecutionResultSchema, PlannedInstanceSchema, ExecutedOutcomeSchema, InstanceStatusSchema, SupervisionFindingSchema, TracedSessionSchema, TracedTestSchema, executionResultDigestOf, selectionDigestOf, } from './schemas/execution-result.js';
+/** Inferred execution-result types. */
+export type { ExecutionResult, PlannedInstance, ExecutedOutcome, InstanceStatus, SupervisionFinding, TracedSession, TracedTest, } from './schemas/execution-result.js';
+/**
+ * Gate receipt (plan 2026-09-13 §5.1, ADR 0005 D3, Phase 4): the NEW
+ * versioned, domain-separated envelope issued only after complete run
+ * success and evidence grading. Signed by the same authority as witness
+ * records (the verifier key, HMAC over GF-canonical JSON, domain
+ * `gateforge.receipt.v1`) — never a repurposed v2 attestation.
+ */
+export { RECEIPT_DOMAIN, RECEIPT_VERSION, gateReceiptMac, verifyGateReceipt, } from './receipt/index.js';
+/** Receipt types. */
+export type { GateReceipt } from './schemas/gate-receipt.js';
+export type { GateReceiptBody } from './receipt/index.js';
+export { GateReceiptSchema, ReceiptVerdictSummarySchema, ReceiptScopeSchema } from './schemas/gate-receipt.js';
+export type { ReceiptVerdictSummary, ReceiptScope } from './schemas/gate-receipt.js';
+export type { ReceiptRejection, ReceiptVerification } from './receipt/index.js';
+/**
+ * Trusted runner supervision (plan Phase 4 item 4, ADR 0005 D2): the
+ * pure expected-set enforcement — planned versus executed instances,
+ * retries, skips/only/fixme, expected failures, teardown errors, shards,
+ * and runner exit, each a typed §5.4 run cause. Any finding fails the
+ * whole run; there is no selective pass out of a failed required suite.
+ */
+export { superviseExecution, enumerationDigestOf, ENUMERATION_DOMAIN } from './supervision/index.js';
+/** Supervision types. */
+export type { PlannedInstanceInput, ExecutedOutcomeInput, SupervisionEnvelopeInput, SupervisionFinding as SupervisionFindingInput, SupervisionResult, TracedSession as TracedSessionInput, TracedTest as TracedTestInput, ExpectedTestInput, } from './supervision/index.js';
+/**
+ * Loads and validates every `*.json` waiver file in a directory against
+ * the injected clock: all five fields mandatory (GF-15), expiry judged
+ * by `now` (GF-16), optional stale-owner hook (GF-17). Synchronous.
+ */
+export { loadWaivers } from './waivers/index.js';
+/**
+ * Waiver writers (the `waive` CLI's storage path): `serializeWaiver`
+ * renders the reviewable 2-space-JSON + trailing-newline house style,
+ * `writeWaiver` writes it creating parent directories as needed.
+ * The only sanctioned programmatic waiver write — renewal/removal stays
+ * a hand-edit (there is deliberately no overwrite).
+ */
+export { serializeWaiver, writeWaiver } from './waivers/index.js';
+/** Fail-closed waiver-configuration error; carries every problem found. */
+export { GateforgeWaiverError } from './waivers/index.js';
+/** One file-scoped waiver-loading problem. */
+export type { WaiverProblem } from './waivers/index.js';
+/** Loader result partitions: valid / stale-owner / expired. */
+export type { WaiverLoadResult, WaiverLoadOptions } from './waivers/index.js';
+/** Loads and validates `.gateforge/baselines/obligations.json` (pin #3). */
+export { loadBaseline } from './baselines/index.js';
+/**
+ * Whether a baseline update is a strict subset (invariant 4): only
+ * removals allowed — `[A, B] → [A, NEW]` fails (GF-07), `[A, B] → [A]`
+ * passes (GF-08).
+ */
+export { canUpdate } from './baselines/index.js';
+/** Builds the next baseline, enforcing the strict-subset rule. */
+export { updateBaseline } from './baselines/index.js';
+/** Serializes a baseline to reviewable 2-space JSON with newline. */
+export { serializeBaseline } from './baselines/index.js';
+/** Writes a baseline, creating parent directories as needed. */
+export { writeBaseline } from './baselines/index.js';
+/** Fail-closed baseline error (load, validation, or update rejection). */
+export { GateforgeBaselineError } from './baselines/index.js';
+/**
+ * THE ONE SANCTIONED BULK-ADD (phase 8 workstream C): builds the
+ * adoption baseline without the subset check — `gateforge adopt` is the
+ * only caller; `updateBaseline` stays shrink-only (GF-07/08 unchanged).
+ */
+export { adoptBaseline } from './baselines/index.js';
+/** The adoption record (phase 8 C): the loud, one-time bulk-add receipt. */
+export { AdoptionRecordSchema, ClassificationBlockedIdsSchema } from './schemas/adoption.js';
+/** Inferred adoption-record type. */
+export type { AdoptionRecord } from './schemas/adoption.js';
+/** Loads `.gateforge/baselines/adoption.json` (null = pre-adoption). */
+export { loadAdoptionRecord, ADOPTION_RECORD_FILENAME } from './baselines/adoption.js';
+/** Writes the adoption record, creating parent directories as needed. */
+export { writeAdoptionRecord } from './baselines/adoption.js';
+/**
+ * The classification layer of the adoption (two-layer adoption):
+ * `adoptClassificationBlocked` normalizes the captured ids for the
+ * receipt; `shrinkClassificationBlocked` is the set's ONLY post-adoption
+ * mutation — strict-subset, shrink-only (GF-07/08 mirrored).
+ */
+export { adoptClassificationBlocked, shrinkClassificationBlocked } from './baselines/adoption.js';
+/**
+ * Renders per-obligation verdicts: `json` (GF-canonical JSON),
+ * `sarif` (SARIF 2.1.0 projection, pin #10), or `text` (the
+ * invariant-8 detector → policy → obligation → evidence-gap trace plus
+ * waiver counts). Deterministic; identical inputs serialize identically.
+ */
+export { renderRun } from './report/index.js';
+/** Exit codes (contract 4): 0 clean/waived, 1 unresolved, 2 config. */
+export { runExitCode } from './report/index.js';
+/** The run exit-code union. */
+export type { RunExitCode } from './report/index.js';
+/** Waiver-population counts for report summaries. */
+export type { WaiverCounts } from './report/index.js';
+/** Options for renderRun (format, blocking entries, counts, manifest). */
+export type { RenderRunOptions } from './report/index.js';
+/** Effective evaluation scope carried by run reports (plan §12.4). */
+export type { ScopeMetadata } from './report/index.js';
+/**
+ * Temporary git repository under the OS tmpdir with pinned
+ * author/committer identity and dates: identical file-tree specs yield
+ * identical commit SHAs. `withTempRepo` wraps a fixture body with
+ * guaranteed cleanup.
+ */
+export { FIXED_GIT_DATE, TempRepo, withTempRepo } from './testing/index.js';
+/** Inferred git-invocation result type. */
+export type { GitResult, TempRepoOptions } from './testing/index.js';
+/**
+ * Injected clocks: `{fixedAt}` constant, `{sequence}` ordered instants
+ * (exhaustion throws — no silent repetition), or `{startAt, stepMs}`
+ * stepping. `now()` always returns canonical ISO-8601.
+ */
+export { makeClock, toIso } from './testing/index.js';
+/** Inferred clock types. */
+export type { ClockSpec, TestClock } from './testing/index.js';
+/**
+ * Injected environment (`withEnv`) and changed-file provider stubs:
+ * `fakeProvider` impersonates any provider identity from an explicit
+ * list; `localStagedProvider` reads a temp repo's real index — the two
+ * halves of GF-09 parity.
+ */
+export { fakeProvider, localStagedProvider, normalizeChangedFiles, withEnv, } from './testing/index.js';
+/** Inferred changed-file-provider type. */
+export type { ChangedFileProvider } from './testing/index.js';
+/**
+ * The GF-19 rule: malformed source ⇒ guaranteed `PARSE_ERROR` finding
+ * with a line number, no crash, no silent resources. `stubDetector` is
+ * the in-process toy-parser detector fixtures use; G5 reuses the rule
+ * with its real detector audit.
+ */
+export { PARSE_ERROR_FINDING, applyParseErrorRule, hasParseErrors, stubDetector, } from './testing/index.js';
+/** Inferred parse-audit and rule types. */
+export type { ParseAudit, ParseAuditEntry, ParseErrorRuleInput, ParseErrorRuleResult, StubDetectorOptions, StubDetectorResult, } from './testing/index.js';
+/**
+ * Gate-runner helper: discover → obligations → evaluate over a temp repo
+ * with injected clock/env/provider and a pin-#9 evaluator (fixtures use
+ * a local double; the real verdict engine conforms structurally).
+ */
+export { runGates } from './testing/index.js';
+/** Inferred gate-runner types. */
+export type { DetectorContribution, EvaluatorVerdict, GateRunResult, ObligationEvaluator, ObligationEvaluatorInput, GateRunVerdict, RunGatesInput, } from './testing/index.js';
+/**
+ * RED-PROBE discipline: run the same guard against correct and
+ * deliberately-broken behavior; a broken probe that passes is a fake
+ * green and fails loudly. Suite-level proof spawns vitest twice
+ * (`spawnVitest` + `writeProbeSuite`); see docs/testing/RED_PROBE.md.
+ */
+export { RedProbeFailure, RedProbeSuiteError, cleanupProbeSuite, formatProbeRecords, runRedProbe, runRedProbes, spawnVitest, writeProbeRecords, writeProbeSuite, } from './testing/index.js';
+/** Inferred red-probe types. */
+export type { RedProbe, RedProbeRecord, VitestRunOptions, VitestRunResult, } from './testing/index.js';
+//# sourceMappingURL=index.d.ts.map