@adrkit/core 0.1.0

package/dist/load/corpus.d.ts

@@ -0,0 +1,20 @@
+import { type Adr } from '../schema/adr.schema.js';
+export declare const RECORD_FILE_PATTERN: RegExp;
+export declare const TEMPLATE_FILE_NAME = "0000-template.md";
+export interface ParsedAdrFile {
+    data: unknown;
+    body: string;
+    path: string;
+    absolutePath: string;
+}
+export interface Corpus {
+    records: Adr[];
+    byId: Map<string, Adr>;
+}
+export declare function isRecordFileName(fileName: string): boolean;
+export declare function normalizeDisplayPath(path: string, cwd?: string): string;
+export declare function discoverAdrFiles(dir?: string, cwd?: string): Promise<string[]>;
+export declare function expandRecordInputs(paths: string[] | undefined, dir?: string, cwd?: string): Promise<string[]>;
+export declare function parseAdrFile(path: string, cwd?: string): Promise<ParsedAdrFile>;
+export declare function loadAdrFile(path: string, cwd?: string): Promise<Adr>;
+export declare function loadCorpus(dir?: string, cwd?: string): Promise<Corpus>;

package/dist/parse/frontmatter.d.ts

@@ -0,0 +1,10 @@
+export type FrontmatterErrorCode = 'missing-frontmatter' | 'unterminated-frontmatter' | 'invalid-yaml';
+export declare class FrontmatterError extends Error {
+    readonly code: FrontmatterErrorCode;
+    constructor(code: FrontmatterErrorCode, message: string);
+}
+export interface ParsedFrontmatter {
+    data: unknown;
+    body: string;
+}
+export declare function parseFrontmatter(source: string): ParsedFrontmatter;

package/dist/scaffold/new.d.ts

@@ -0,0 +1,26 @@
+export interface NewAdrOptions {
+    title: string;
+    status?: string;
+    dir?: string;
+    cwd?: string;
+    date?: string;
+    write?: boolean;
+}
+export interface NewAdrResult {
+    id: string;
+    path: string;
+    content: string;
+}
+export declare class ScaffoldError extends Error {
+    readonly code: 'usage' | 'exists';
+    constructor(code: 'usage' | 'exists', message: string);
+}
+export declare function slugifyTitle(title: string): string;
+export declare function nextSequentialId(dir: string, cwd: string): Promise<string>;
+export declare function renderAdrRecord(options: {
+    id: string;
+    title: string;
+    status: string;
+    date: string;
+}): string;
+export declare function createAdr(options: NewAdrOptions): Promise<NewAdrResult>;

package/dist/schema/adr.schema.d.ts

@@ -0,0 +1,416 @@
+/**
+ * @adrkit/core — ADR frontmatter schema
+ *
+ * Single source of truth for the typed half of a decision record. The JSON
+ * Schema in ./adr.schema.json is generated from this file (`bun run schema:emit`)
+ * so non-TS consumers — editors, CI in other languages, IDP plugins — get the
+ * same contract.
+ *
+ * Targets Zod 4. Deliberately avoids `.brand()` and other Zod-only constructs
+ * in the public shapes so the JSON Schema emit stays lossless.
+ */
+import { z } from 'zod';
+export declare const SCHEMA_VERSION: "0.1.0";
+/** `@handle`, `team:platform`, or an email address. */
+export declare const Identity: z.ZodString;
+/** `0042` (same log) or `payments:0012` (federated). */
+export declare const AdrRef: z.ZodString;
+/**
+ * `rejected` is retained on purpose. The decision *not* to do something is the
+ * one most often re-litigated, and the graveyard is where "we tried that in
+ * 2023" knowledge lives.
+ */
+export declare const Status: z.ZodEnum<{
+    draft: "draft";
+    proposed: "proposed";
+    accepted: "accepted";
+    rejected: "rejected";
+    superseded: "superseded";
+    deprecated: "deprecated";
+}>;
+export declare const Scope: z.ZodEnum<{
+    component: "component";
+    domain: "domain";
+    org: "org";
+}>;
+export declare const Reversibility: z.ZodEnum<{
+    "two-way-door": "two-way-door";
+    "one-way-door": "one-way-door";
+    unknown: "unknown";
+}>;
+export declare const BlastRadius: z.ZodEnum<{
+    component: "component";
+    org: "org";
+    team: "team";
+    "cross-team": "cross-team";
+}>;
+export declare const ReviewTier: z.ZodEnum<{
+    auto: "auto";
+    async: "async";
+    arb: "arb";
+}>;
+export declare const Severity: z.ZodEnum<{
+    error: "error";
+    warn: "warn";
+    info: "info";
+}>;
+export declare const EscalationReason: z.ZodEnum<{
+    "one-way-door": "one-way-door";
+    "cost-threshold": "cost-threshold";
+    "security-surface": "security-surface";
+    "data-residency": "data-residency";
+    regulatory: "regulatory";
+    "contradicts-accepted-adr": "contradicts-accepted-adr";
+    "low-confidence": "low-confidence";
+    "pass-disagreement": "pass-disagreement";
+    "agent-authored-production": "agent-authored-production";
+    "novel-no-precedent": "novel-no-precedent";
+    "human-requested": "human-requested";
+}>;
+export declare const AffectsType: z.ZodEnum<{
+    path: "path";
+    entity: "entity";
+    package: "package";
+    resource: "resource";
+    api: "api";
+    data: "data";
+}>;
+export declare const AffectsMatcher: z.ZodObject<{
+    type: z.ZodEnum<{
+        path: "path";
+        entity: "entity";
+        package: "package";
+        resource: "resource";
+        api: "api";
+        data: "data";
+    }>;
+    pattern: z.ZodString;
+    repo: z.ZodOptional<z.ZodString>;
+    negate: z.ZodDefault<z.ZodBoolean>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const Assertion: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    engine: z.ZodEnum<{
+        custom: "custom";
+        rego: "rego";
+        jsonpath: "jsonpath";
+        grep: "grep";
+    }>;
+    expression: z.ZodOptional<z.ZodString>;
+    expressionFile: z.ZodOptional<z.ZodString>;
+    input: z.ZodDefault<z.ZodEnum<{
+        custom: "custom";
+        source: "source";
+        "iac-plan": "iac-plan";
+        sbom: "sbom";
+        openapi: "openapi";
+        catalog: "catalog";
+    }>>;
+    severity: z.ZodEnum<{
+        error: "error";
+        warn: "warn";
+        info: "info";
+    }>;
+}, z.core.$strict>;
+export declare const Provenance: z.ZodObject<{
+    authoredBy: z.ZodDefault<z.ZodEnum<{
+        human: "human";
+        agent: "agent";
+        "agent-drafted": "agent-drafted";
+    }>>;
+    agent: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        harness: z.ZodOptional<z.ZodString>;
+        runId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    ratifiedBy: z.ZodOptional<z.ZodString>;
+    sourceArtifact: z.ZodOptional<z.ZodString>;
+    importedFrom: z.ZodOptional<z.ZodObject<{
+        sourceKind: z.ZodEnum<{
+            madr: "madr";
+            "agent-log": "agent-log";
+            "plan-artifact": "plan-artifact";
+            other: "other";
+        }>;
+        sourceRef: z.ZodString;
+        fingerprint: z.ZodString;
+        importedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const Objection: z.ZodObject<{
+    by: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    resolved: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const Review: z.ZodObject<{
+    tier: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        async: "async";
+        arb: "arb";
+    }>>;
+    tierReason: z.ZodOptional<z.ZodString>;
+    queuedAt: z.ZodOptional<z.ZodString>;
+    slaDays: z.ZodOptional<z.ZodNumber>;
+    escalatedAt: z.ZodOptional<z.ZodString>;
+    decidedAt: z.ZodOptional<z.ZodString>;
+    quorum: z.ZodOptional<z.ZodNumber>;
+    approvals: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    objections: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        by: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        resolved: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const DeterministicFinding: z.ZodObject<{
+    rule: z.ZodString;
+    severity: z.ZodEnum<{
+        error: "error";
+        warn: "warn";
+        info: "info";
+    }>;
+    message: z.ZodOptional<z.ZodString>;
+    adr: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const Evaluation: z.ZodObject<{
+    ranAt: z.ZodOptional<z.ZodString>;
+    evaluatorVersion: z.ZodOptional<z.ZodString>;
+    rubricVersion: z.ZodOptional<z.ZodString>;
+    scores: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    escalate: z.ZodOptional<z.ZodBoolean>;
+    escalationReasons: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        "one-way-door": "one-way-door";
+        "cost-threshold": "cost-threshold";
+        "security-surface": "security-surface";
+        "data-residency": "data-residency";
+        regulatory: "regulatory";
+        "contradicts-accepted-adr": "contradicts-accepted-adr";
+        "low-confidence": "low-confidence";
+        "pass-disagreement": "pass-disagreement";
+        "agent-authored-production": "agent-authored-production";
+        "novel-no-precedent": "novel-no-precedent";
+        "human-requested": "human-requested";
+    }>>>;
+    deterministicFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        rule: z.ZodString;
+        severity: z.ZodEnum<{
+            error: "error";
+            warn: "warn";
+            info: "info";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+        adr: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const ExternalRef: z.ZodObject<{
+    type: z.ZodEnum<{
+        other: "other";
+        issue: "issue";
+        pr: "pr";
+        rfc: "rfc";
+        incident: "incident";
+        doc: "doc";
+        meeting: "meeting";
+        control: "control";
+    }>;
+    id: z.ZodOptional<z.ZodString>;
+    url: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const AdrFrontmatter: z.ZodObject<{
+    schemaVersion: z.ZodDefault<z.ZodString>;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        proposed: "proposed";
+        accepted: "accepted";
+        rejected: "rejected";
+        superseded: "superseded";
+        deprecated: "deprecated";
+    }>;
+    date: z.ZodString;
+    created: z.ZodOptional<z.ZodString>;
+    deciders: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    consulted: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    informed: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    scope: z.ZodDefault<z.ZodEnum<{
+        component: "component";
+        domain: "domain";
+        org: "org";
+    }>>;
+    domain: z.ZodOptional<z.ZodString>;
+    reversibility: z.ZodDefault<z.ZodEnum<{
+        "two-way-door": "two-way-door";
+        "one-way-door": "one-way-door";
+        unknown: "unknown";
+    }>>;
+    blastRadius: z.ZodDefault<z.ZodEnum<{
+        component: "component";
+        org: "org";
+        team: "team";
+        "cross-team": "cross-team";
+    }>>;
+    supersedes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    supersededBy: z.ZodOptional<z.ZodString>;
+    relatesTo: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    conflictsWith: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    affects: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            path: "path";
+            entity: "entity";
+            package: "package";
+            resource: "resource";
+            api: "api";
+            data: "data";
+        }>;
+        pattern: z.ZodString;
+        repo: z.ZodOptional<z.ZodString>;
+        negate: z.ZodDefault<z.ZodBoolean>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    assertions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        engine: z.ZodEnum<{
+            custom: "custom";
+            rego: "rego";
+            jsonpath: "jsonpath";
+            grep: "grep";
+        }>;
+        expression: z.ZodOptional<z.ZodString>;
+        expressionFile: z.ZodOptional<z.ZodString>;
+        input: z.ZodDefault<z.ZodEnum<{
+            custom: "custom";
+            source: "source";
+            "iac-plan": "iac-plan";
+            sbom: "sbom";
+            openapi: "openapi";
+            catalog: "catalog";
+        }>>;
+        severity: z.ZodEnum<{
+            error: "error";
+            warn: "warn";
+            info: "info";
+        }>;
+    }, z.core.$strict>>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        authoredBy: z.ZodDefault<z.ZodEnum<{
+            human: "human";
+            agent: "agent";
+            "agent-drafted": "agent-drafted";
+        }>>;
+        agent: z.ZodOptional<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            harness: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        ratifiedBy: z.ZodOptional<z.ZodString>;
+        sourceArtifact: z.ZodOptional<z.ZodString>;
+        importedFrom: z.ZodOptional<z.ZodObject<{
+            sourceKind: z.ZodEnum<{
+                madr: "madr";
+                "agent-log": "agent-log";
+                "plan-artifact": "plan-artifact";
+                other: "other";
+            }>;
+            sourceRef: z.ZodString;
+            fingerprint: z.ZodString;
+            importedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    review: z.ZodOptional<z.ZodObject<{
+        tier: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            async: "async";
+            arb: "arb";
+        }>>;
+        tierReason: z.ZodOptional<z.ZodString>;
+        queuedAt: z.ZodOptional<z.ZodString>;
+        slaDays: z.ZodOptional<z.ZodNumber>;
+        escalatedAt: z.ZodOptional<z.ZodString>;
+        decidedAt: z.ZodOptional<z.ZodString>;
+        quorum: z.ZodOptional<z.ZodNumber>;
+        approvals: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        objections: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            by: z.ZodString;
+            summary: z.ZodOptional<z.ZodString>;
+            resolved: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    evaluation: z.ZodOptional<z.ZodObject<{
+        ranAt: z.ZodOptional<z.ZodString>;
+        evaluatorVersion: z.ZodOptional<z.ZodString>;
+        rubricVersion: z.ZodOptional<z.ZodString>;
+        scores: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        escalate: z.ZodOptional<z.ZodBoolean>;
+        escalationReasons: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            "one-way-door": "one-way-door";
+            "cost-threshold": "cost-threshold";
+            "security-surface": "security-surface";
+            "data-residency": "data-residency";
+            regulatory: "regulatory";
+            "contradicts-accepted-adr": "contradicts-accepted-adr";
+            "low-confidence": "low-confidence";
+            "pass-disagreement": "pass-disagreement";
+            "agent-authored-production": "agent-authored-production";
+            "novel-no-precedent": "novel-no-precedent";
+            "human-requested": "human-requested";
+        }>>>;
+        deterministicFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            rule: z.ZodString;
+            severity: z.ZodEnum<{
+                error: "error";
+                warn: "warn";
+                info: "info";
+            }>;
+            message: z.ZodOptional<z.ZodString>;
+            adr: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    externalRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            other: "other";
+            issue: "issue";
+            pr: "pr";
+            rfc: "rfc";
+            incident: "incident";
+            doc: "doc";
+            meeting: "meeting";
+            control: "control";
+        }>;
+        id: z.ZodOptional<z.ZodString>;
+        url: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    complianceControls: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    reviewBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type AdrFrontmatter = z.infer<typeof AdrFrontmatter>;
+export interface Adr {
+    frontmatter: AdrFrontmatter;
+    /** Raw markdown body below the frontmatter. */
+    body: string;
+    /** Repo-relative path, e.g. docs/adr/0042-use-postgres-for-the-index.md */
+    path: string;
+    /** Log name for federated corpora; undefined for single-repo. */
+    log?: string;
+}
+export type AdrRef = z.infer<typeof AdrRef>;
+export type AffectsType = z.infer<typeof AffectsType>;
+export type AffectsMatcher = z.infer<typeof AffectsMatcher>;
+export type Assertion = z.infer<typeof Assertion>;
+export type Severity = z.infer<typeof Severity>;
+export type EscalationReason = z.infer<typeof EscalationReason>;
+export type DeterministicFinding = z.infer<typeof DeterministicFinding>;
+export type Evaluation = z.infer<typeof Evaluation>;
+export type Status = z.infer<typeof Status>;
+export type Scope = z.infer<typeof Scope>;
+export type Reversibility = z.infer<typeof Reversibility>;
+export type BlastRadius = z.infer<typeof BlastRadius>;

package/dist/schema/adr.schema.js

@@ -0,0 +1,182 @@
+// src/schema/adr.schema.ts
+import { z } from "zod";
+var SCHEMA_VERSION = "0.1.0";
+var Identity = z.string().regex(/^(@[A-Za-z0-9-]+|team:[a-z0-9-]+|[^@\s]+@[^@\s]+\.[^@\s]+)$/, "Expected @handle, team:slug, or an email address");
+var AdrRef = z.string().regex(/^(([a-z0-9][a-z0-9-]*):)?([0-9]{4,}|[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26})$/, "Expected an ADR id, optionally prefixed with a log name");
+var IsoDate = z.string().date();
+var IsoDateTime = z.string().datetime({ offset: true });
+var Slug = z.string().regex(/^[a-z0-9][a-z0-9-]*$/);
+var strictObject = (shape) => z.strictObject(shape);
+var uniqueArray = (item) => z.array(item).refine((xs) => new Set(xs.map((x) => JSON.stringify(x))).size === xs.length, {
+  message: "Items must be unique"
+}).meta({ uniqueItems: true });
+var Status = z.enum([
+  "draft",
+  "proposed",
+  "accepted",
+  "rejected",
+  "superseded",
+  "deprecated"
+]);
+var Scope = z.enum(["component", "domain", "org"]);
+var Reversibility = z.enum(["two-way-door", "one-way-door", "unknown"]);
+var BlastRadius = z.enum(["component", "team", "cross-team", "org"]);
+var ReviewTier = z.enum(["auto", "async", "arb"]);
+var Severity = z.enum(["error", "warn", "info"]);
+var EscalationReason = z.enum([
+  "one-way-door",
+  "cost-threshold",
+  "security-surface",
+  "data-residency",
+  "regulatory",
+  "contradicts-accepted-adr",
+  "low-confidence",
+  "pass-disagreement",
+  "agent-authored-production",
+  "novel-no-precedent",
+  "human-requested"
+]);
+var AffectsType = z.enum([
+  "path",
+  "entity",
+  "package",
+  "resource",
+  "api",
+  "data"
+]);
+var AffectsMatcher = strictObject({
+  type: AffectsType,
+  pattern: z.string().min(1),
+  repo: z.string().optional(),
+  negate: z.boolean().default(false),
+  note: z.string().optional()
+});
+var Assertion = strictObject({
+  id: Slug,
+  description: z.string().optional(),
+  engine: z.enum(["rego", "jsonpath", "grep", "custom"]),
+  expression: z.string().optional(),
+  expressionFile: z.string().optional(),
+  input: z.enum(["source", "iac-plan", "sbom", "openapi", "catalog", "custom"]).default("source"),
+  severity: Severity
+});
+var Provenance = strictObject({
+  authoredBy: z.enum(["human", "agent", "agent-drafted"]).default("human"),
+  agent: strictObject({
+    name: z.string().optional(),
+    model: z.string().optional(),
+    harness: z.string().optional(),
+    runId: z.string().optional()
+  }).optional(),
+  ratifiedBy: Identity.optional(),
+  sourceArtifact: z.string().optional(),
+  importedFrom: strictObject({
+    sourceKind: z.enum(["madr", "agent-log", "plan-artifact", "other"]),
+    sourceRef: z.string(),
+    fingerprint: z.string(),
+    importedAt: IsoDateTime.optional()
+  }).optional()
+});
+var Objection = strictObject({
+  by: Identity,
+  summary: z.string().optional(),
+  resolved: z.boolean().default(false)
+});
+var Review = strictObject({
+  tier: ReviewTier.optional(),
+  tierReason: z.string().optional(),
+  queuedAt: IsoDateTime.optional(),
+  slaDays: z.number().int().min(0).optional(),
+  escalatedAt: IsoDateTime.optional(),
+  decidedAt: IsoDateTime.optional(),
+  quorum: z.number().int().min(1).optional(),
+  approvals: z.array(Identity).default([]),
+  objections: z.array(Objection).default([])
+});
+var DeterministicFinding = strictObject({
+  rule: z.string(),
+  severity: Severity,
+  message: z.string().optional(),
+  adr: AdrRef.optional()
+});
+var Evaluation = strictObject({
+  ranAt: IsoDateTime.optional(),
+  evaluatorVersion: z.string().optional(),
+  rubricVersion: z.string().optional(),
+  scores: z.record(z.string(), z.number().min(0).max(4)).optional(),
+  confidence: z.number().min(0).max(1).optional(),
+  escalate: z.boolean().optional(),
+  escalationReasons: z.array(EscalationReason).default([]),
+  deterministicFindings: z.array(DeterministicFinding).default([])
+});
+var ExternalRef = strictObject({
+  type: z.enum(["issue", "pr", "rfc", "incident", "doc", "meeting", "control", "other"]),
+  id: z.string().optional(),
+  url: z.string().url(),
+  label: z.string().optional()
+});
+var AdrFrontmatter = strictObject({
+  schemaVersion: z.string().regex(/^\d+\.\d+\.\d+$/).default(SCHEMA_VERSION),
+  id: z.string().regex(/^([0-9]{4,}|[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26})$/),
+  title: z.string().min(3).max(120),
+  status: Status,
+  date: IsoDate,
+  created: IsoDate.optional(),
+  deciders: z.array(Identity).default([]),
+  consulted: z.array(Identity).default([]),
+  informed: z.array(Identity).default([]),
+  tags: uniqueArray(Slug).default([]),
+  scope: Scope.default("component"),
+  domain: z.string().optional(),
+  reversibility: Reversibility.default("unknown"),
+  blastRadius: BlastRadius.default("component"),
+  supersedes: uniqueArray(AdrRef).default([]),
+  supersededBy: AdrRef.optional(),
+  relatesTo: uniqueArray(AdrRef).default([]),
+  conflictsWith: z.array(AdrRef).default([]),
+  affects: z.array(AffectsMatcher).default([]),
+  assertions: z.array(Assertion).default([]),
+  provenance: Provenance.optional(),
+  review: Review.optional(),
+  evaluation: Evaluation.optional(),
+  externalRefs: z.array(ExternalRef).default([]),
+  complianceControls: uniqueArray(z.string()).default([]),
+  reviewBy: IsoDate.optional()
+}).refine((a) => a.status === "superseded" ? Boolean(a.supersededBy) : true, {
+  message: 'status "superseded" requires supersededBy',
+  path: ["supersededBy"]
+}).refine((a) => a.supersededBy ? a.status === "superseded" : true, {
+  message: 'supersededBy is set but status is not "superseded"',
+  path: ["status"]
+}).refine((a) => a.status !== "accepted" || a.deciders.length > 0 || Boolean(a.provenance?.importedFrom), {
+  message: "an accepted decision must name at least one decider, unless it was imported",
+  path: ["deciders"]
+}).refine((a) => a.status !== "accepted" || a.provenance?.authoredBy !== "agent" || Boolean(a.provenance?.ratifiedBy), {
+  message: 'an agent-authored record cannot reach "accepted" without a named human ratifier',
+  path: ["provenance", "ratifiedBy"]
+}).refine((a) => !(a.reversibility === "one-way-door" && a.review?.tier === "auto"), {
+  message: "one-way-door decisions may not take the auto-approve fast path",
+  path: ["review", "tier"]
+});
+export {
+  Status,
+  Severity,
+  Scope,
+  SCHEMA_VERSION,
+  ReviewTier,
+  Review,
+  Reversibility,
+  Provenance,
+  Objection,
+  Identity,
+  ExternalRef,
+  Evaluation,
+  EscalationReason,
+  DeterministicFinding,
+  BlastRadius,
+  Assertion,
+  AffectsType,
+  AffectsMatcher,
+  AdrRef,
+  AdrFrontmatter
+};

package/dist/schema/emit.cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/schema/emit.d.ts

@@ -0,0 +1,6 @@
+export declare const ADR_SCHEMA_ID: string;
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare function emitJsonSchema(): JsonValue;
+export declare function stringifyJsonSchema(schema?: JsonValue): string;