@invariant-ui/cli 0.0.0-stage → 0.2.0

package/dist/contract/archetype-checks.js

@@ -0,0 +1,153 @@
+/** The parts of a pattern, with a variation's role changes and additions applied. */
+export function effectiveParts(p, variationId) {
+    const base = (p.composition?.parts ?? []).map((x) => ({
+        name: x.name,
+        ref: x.ref,
+        role: x.role,
+        region: x.region
+    }));
+    const v = variationId === undefined ? undefined : p.variations?.find((x) => x.name === variationId);
+    if (!v)
+        return base;
+    const roles = new Map((v.roles ?? []).map((r) => [r.part, r.role]));
+    return [
+        ...base.map((x) => ({ ...x, role: roles.get(x.name) ?? x.role })),
+        ...(v.parts ?? []).map((x) => ({ name: x.name, ref: x.ref, role: x.role, region: x.region }))
+    ];
+}
+const COMPOSING = new Set(["composes", "contains", "uses", "requires"]);
+/** Patterns a pattern builds on: its non-prohibited parts that are patterns, and what it composes or contains. */
+function uses(p, parts) {
+    const out = new Set();
+    for (const x of parts)
+        if (x.role !== "prohibited" && x.ref.startsWith("pattern:"))
+            out.add(x.ref);
+    for (const r of p.relationships ?? [])
+        if (COMPOSING.has(r.type) && r.target.startsWith("pattern:"))
+            out.add(r.target);
+    return [...out].sort();
+}
+/**
+ * Everything reachable from a pattern's effective parts, with the chain of patterns that leads to it. Patterns
+ * (and the components their parts name) are both included. Nested patterns contribute their base composition.
+ */
+function reach(byId, root, parts) {
+    const patterns = new Map();
+    const refs = new Map();
+    const seen = new Set([root.id]);
+    const walk = (p, ps, chain) => {
+        for (const x of ps)
+            if (x.role !== "prohibited" && !refs.has(x.ref))
+                refs.set(x.ref, chain);
+        for (const next of uses(p, ps)) {
+            if (!refs.has(next))
+                refs.set(next, chain);
+            if (seen.has(next))
+                continue;
+            seen.add(next);
+            const n = byId.get(next);
+            if (!n)
+                continue;
+            patterns.set(next, [...chain, next]);
+            walk(n, effectiveParts(n), [...chain, next]);
+        }
+    };
+    walk(root, parts, [root.id]);
+    return { patterns, refs };
+}
+const label = (v) => (v === undefined ? "" : ` in variation "${v}"`);
+/** A variation changes real parts, adds uniquely named ones, and places them in real regions. */
+export function checkVariations(p, error) {
+    const base = new Set((p.composition?.parts ?? []).map((x) => x.name));
+    const regions = new Set((p.layout?.regions ?? []).map((r) => r.name));
+    const names = (p.variations ?? []).map((v) => v.name);
+    for (const name of new Set(names.filter((x, i) => names.indexOf(x) !== i)))
+        error("contract.pattern-duplicate-name", `${p.id} has more than one variation named "${name}"`, p.id);
+    for (const v of p.variations ?? []) {
+        const changed = new Set();
+        for (const r of v.roles ?? []) {
+            if (!base.has(r.part))
+                error("contract.pattern-variation-unknown-part", `${p.id} variation "${v.name}" changes part "${r.part}", which the composition does not have`, p.id);
+            if (changed.has(r.part))
+                error("contract.pattern-duplicate-name", `${p.id} variation "${v.name}" changes part "${r.part}" twice`, p.id);
+            changed.add(r.part);
+        }
+        const added = new Set();
+        for (const x of v.parts ?? []) {
+            if (base.has(x.name) || added.has(x.name))
+                error("contract.pattern-duplicate-name", `${p.id} variation "${v.name}" adds a part named "${x.name}", which already exists`, p.id);
+            added.add(x.name);
+            if (x.region !== undefined && !regions.has(x.region))
+                error("contract.pattern-region-unknown", `${p.id} variation "${v.name}" places part "${x.name}" in unknown region "${x.region}"`, p.id);
+        }
+    }
+}
+/**
+ * Follows what each pattern composes, through the patterns it uses, and reports what cannot hold together:
+ * two patterns declared prohibited together that one blueprint composes, a part a blueprint prohibits that
+ * something it composes brings back, a pattern that another supersedes, and a required region nothing fills.
+ * Each pattern is checked as written and once per variation.
+ */
+export function checkArchetypes(contract, error, warn) {
+    const byId = new Map(contract.patterns.map((p) => [p.id, p]));
+    const supersededBy = new Map();
+    for (const p of contract.patterns)
+        for (const r of p.relationships ?? [])
+            if (r.type === "supersedes")
+                supersededBy.set(r.target, p.id);
+    const reported = new Set();
+    const once = (key, fn) => {
+        if (reported.has(key))
+            return;
+        reported.add(key);
+        fn();
+    };
+    for (const p of contract.patterns) {
+        const ids = [undefined, ...(p.variations ?? []).map((v) => v.name)];
+        for (const variation of ids) {
+            const parts = effectiveParts(p, variation);
+            const { patterns, refs } = reach(byId, p, parts);
+            const inside = new Set([p.id, ...patterns.keys()]);
+            for (const id of inside) {
+                const x = byId.get(id);
+                for (const rel of x?.relationships ?? []) {
+                    if (rel.type !== "prohibited-with" || rel.target === id || !inside.has(rel.target))
+                        continue;
+                    const [a, b] = [id, rel.target].sort();
+                    // Base first: a pair already reported for the blueprint as written is not repeated for its variations.
+                    once(`${p.id}|${a}+${b}`, () => error("contract.pattern-prohibited-combination", `${p.id}${label(variation)} composes both ${a} and ${b}, which are prohibited together (${id} prohibited-with ${rel.target})`, p.id));
+                }
+            }
+            for (const part of parts) {
+                if (part.role !== "prohibited")
+                    continue;
+                const chain = refs.get(part.ref);
+                // A part is a slot: another slot of the same pattern using the same component is not a conflict. Only what
+                // a composed pattern brings in is.
+                if (chain === undefined || chain.length < 2)
+                    continue;
+                once(`${p.id}|prohibits|${part.ref}|${part.name}`, () => error("contract.pattern-prohibited-conflict", `${p.id}${label(variation)} prohibits ${part.ref} (part "${part.name}"), but ${chain.join(" -> ")} brings it in`, p.id));
+            }
+            if (variation === undefined)
+                for (const target of [...refs.keys()].filter((r) => r.startsWith("pattern:"))) {
+                    const by = supersededBy.get(target);
+                    if (by !== undefined && by !== p.id)
+                        once(`${p.id}|superseded|${target}`, () => warn("contract.pattern-superseded-reference", `${p.id} builds on ${target}, which ${by} supersedes`, p.id));
+                }
+        }
+        if (p.inheritsConstraints === true) {
+            if (!p.appliesTo?.paths)
+                error("contract.pattern-inheritance-unscoped", `${p.id} inherits constraints but names no appliesTo.paths, so there is no way to know which files to hold to them`, p.id);
+            if (!p.composition)
+                warn("contract.pattern-inheritance-empty", `${p.id} inherits constraints but composes nothing, so there is nothing to inherit`, p.id);
+        }
+        if (p.layout && p.composition)
+            for (const r of p.layout.regions) {
+                if (!r.required)
+                    continue;
+                if (!p.composition.parts.some((x) => x.role !== "prohibited" && x.region === r.name))
+                    warn("contract.pattern-region-unfilled", `${p.id} requires region "${r.name}", but no composition part is placed in it`, p.id);
+            }
+    }
+}
+//# sourceMappingURL=archetype-checks.js.map

package/dist/contract/components.js

@@ -0,0 +1,102 @@
+import { z } from "zod";
+import { factsSchema } from "./facts.js";
+import { componentIdSchema, entityIdSchema, extensionsSchema, frameworkSchema, jsonValueSchema, slugSchema, sourceIdSchema } from "./primitives.js";
+export const deprecationSchema = z.strictObject({
+    reason: z.string().min(1).optional(),
+    replacedBy: entityIdSchema.optional()
+});
+/** Framework-neutral type description. `text` is the source's own spelling. */
+export const typeRefSchema = z.strictObject({
+    text: z.string().min(1),
+    kind: z
+        .enum([
+        "string",
+        "number",
+        "boolean",
+        "enum",
+        "function",
+        "component",
+        "object",
+        "array",
+        "union",
+        "unknown"
+    ])
+        .optional()
+});
+export const propSchema = z.strictObject({
+    name: z.string().min(1),
+    type: typeRefSchema,
+    required: z.boolean(),
+    default: jsonValueSchema.optional(),
+    allowedValues: z.array(z.union([z.string(), z.number().finite(), z.boolean()])).optional(),
+    description: z.string().optional(),
+    deprecated: deprecationSchema.optional(),
+    extensions: extensionsSchema.optional()
+});
+export const eventSchema = z.strictObject({
+    name: z.string().min(1),
+    payload: typeRefSchema.optional(),
+    description: z.string().optional(),
+    deprecated: deprecationSchema.optional(),
+    extensions: extensionsSchema.optional()
+});
+export const slotSchema = z.strictObject({
+    name: z.string().min(1),
+    description: z.string().optional(),
+    required: z.boolean().optional(),
+    accepts: z.array(componentIdSchema).optional(),
+    extensions: extensionsSchema.optional()
+});
+export const variantSchema = z.strictObject({
+    name: z.string().min(1),
+    values: z.array(z.string().min(1)).min(1),
+    default: z.string().min(1).optional(),
+    description: z.string().optional()
+});
+export const stateSchema = z.strictObject({ name: z.string().min(1), description: z.string().optional() });
+export const accessibilitySchema = z.strictObject({
+    role: z.string().min(1).optional(),
+    attributes: z.array(z.string().min(1)).optional(),
+    keyboard: z.array(z.string().min(1)).optional(),
+    requirements: z.array(z.string().min(1)).optional()
+});
+export const exampleSchema = z.strictObject({
+    id: slugSchema,
+    title: z.string().optional(),
+    language: z.string().min(1),
+    code: z.string().min(1),
+    sourceId: sourceIdSchema.optional()
+});
+export const relationshipSchema = z.strictObject({
+    type: z.enum(["contains", "requires-parent", "commonly-used-with", "extends"]),
+    target: componentIdSchema
+});
+/** One concrete implementation of a conceptual component, in one framework, from one source. */
+export const implementationSchema = z.strictObject({
+    id: slugSchema,
+    framework: frameworkSchema,
+    sourceId: sourceIdSchema,
+    packageName: z.string().min(1).optional(),
+    exportName: z.string().min(1).optional(),
+    importPath: z.string().min(1).optional(),
+    extensions: extensionsSchema.optional()
+});
+export const componentSchema = z.strictObject({
+    id: componentIdSchema,
+    name: z.string().min(1),
+    description: z.string().optional(),
+    lifecycle: z.enum(["stable", "experimental", "deprecated"]).optional(),
+    deprecated: deprecationSchema.optional(),
+    implementations: z.array(implementationSchema),
+    props: z.array(propSchema),
+    events: z.array(eventSchema),
+    slots: z.array(slotSchema),
+    variants: z.array(variantSchema),
+    states: z.array(stateSchema),
+    accessibility: accessibilitySchema.optional(),
+    examples: z.array(exampleSchema),
+    composition: z.array(relationshipSchema),
+    facts: factsSchema,
+    extensions: extensionsSchema.optional()
+});
+//# sourceMappingURL=components.js.map

package/dist/contract/conflicts.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { evidenceIdSchema } from "./evidence.js";
+import { factStatusSchema } from "./facts.js";
+import { conflictIdSchema, entityIdSchema, factPathSchema, isoTimestampSchema, jsonValueSchema, sourceIdSchema } from "./primitives.js";
+export const claimSchema = z.strictObject({
+    sourceId: sourceIdSchema,
+    /** Absent means the source asserts the field does not exist or has no value, which is distinct from null. */
+    value: jsonValueSchema.optional(),
+    status: factStatusSchema,
+    evidenceIds: z.array(evidenceIdSchema).min(1)
+});
+export const conflictSchema = z.strictObject({
+    id: conflictIdSchema,
+    type: z.enum([
+        "value-mismatch",
+        "existence-mismatch",
+        "deprecation-mismatch",
+        "identity-ambiguity",
+        "token-value-mismatch",
+        "documentation-gap"
+    ]),
+    severity: z.enum(["error", "warning", "info"]),
+    subject: entityIdSchema,
+    path: factPathSchema.optional(),
+    claims: z.array(claimSchema).min(2),
+    suggestedResolution: z.string().min(1).optional(),
+    resolution: z.discriminatedUnion("state", [
+        z.strictObject({ state: z.literal("open") }),
+        z.strictObject({
+            state: z.enum(["resolved", "accepted", "dismissed"]),
+            /** The chosen source, when the resolution selects one claim. Losing claims are never deleted. */
+            chosenSourceId: sourceIdSchema.optional(),
+            decidedBy: z.string().min(1),
+            decidedAt: isoTimestampSchema,
+            note: z.string().min(1).optional()
+        })
+    ])
+});
+//# sourceMappingURL=conflicts.js.map

package/dist/contract/contract.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { componentSchema } from "./components.js";
+import { conflictSchema } from "./conflicts.js";
+import { constraintSchema, guidelineSchema, patternSchema, policySchema } from "./knowledge.js";
+import { frameworkSchema, isoTimestampSchema, sha256HexSchema, slugSchema } from "./primitives.js";
+import { sourceSchema } from "./sources.js";
+import { themeSchema, tokenSchema } from "./tokens.js";
+/**
+ * 1.1.0 added pattern contracts. Every new field is optional, so a 1.0.0 document is also a valid 1.1.0 document:
+ * nothing is rewritten when one is read, and its content hash stays valid. Writers emit the current version.
+ */
+export const SUPPORTED_CONTRACT_VERSIONS = ["1.0.0", "1.1.0"];
+export const CONTRACT_VERSION = "1.1.0";
+export const contractMetadataSchema = z.strictObject({
+    /** Stable identity of the design system across contract versions. */
+    contractId: slugSchema,
+    name: z.string().min(1),
+    description: z.string().optional(),
+    compilerVersion: z.string().min(1),
+    frameworks: z.array(frameworkSchema),
+    /** Excluded from the content hash. */
+    compiledAt: isoTimestampSchema
+});
+export const integritySchema = z.strictObject({
+    algorithm: z.literal("sha256"),
+    contentHash: sha256HexSchema
+});
+/**
+ * Canonical design-system contract. Collections are sorted by id; per-source versions live in
+ * `sources[].version`. Evidence is stored in a separate evidence file and referenced by id.
+ */
+export const contractSchema = z.strictObject({
+    contractVersion: z.enum(SUPPORTED_CONTRACT_VERSIONS),
+    metadata: contractMetadataSchema,
+    sources: z.array(sourceSchema),
+    themes: z.array(themeSchema),
+    components: z.array(componentSchema),
+    tokens: z.array(tokenSchema),
+    patterns: z.array(patternSchema),
+    guidelines: z.array(guidelineSchema),
+    constraints: z.array(constraintSchema),
+    policies: z.array(policySchema),
+    conflicts: z.array(conflictSchema),
+    integrity: integritySchema
+});
+//# sourceMappingURL=contract.js.map

package/dist/contract/evidence.js

@@ -0,0 +1,84 @@
+import { hashJson } from "../shared/index.js";
+import { z } from "zod";
+import { confidenceSchema, isoTimestampSchema, relativePathSchema, sha256HexSchema, sourceIdSchema } from "./primitives.js";
+export const EVIDENCE_VERSION = "1.0.0";
+export const evidenceIdSchema = z.string().regex(/^ev_[0-9a-f]{24}$/);
+export const evidenceLocationSchema = z.discriminatedUnion("type", [
+    z.strictObject({
+        type: z.literal("file"),
+        path: relativePathSchema,
+        line: z.number().int().positive().optional(),
+        column: z.number().int().positive().optional(),
+        endLine: z.number().int().positive().optional(),
+        endColumn: z.number().int().positive().optional()
+    }),
+    z.strictObject({
+        type: z.literal("document"),
+        documentId: z.string().min(1),
+        title: z.string().min(1).optional(),
+        section: z.string().min(1).optional(),
+        url: z.url().optional()
+    }),
+    z.strictObject({ type: z.literal("url"), url: z.url(), pointer: z.string().optional() }),
+    z.strictObject({
+        type: z.literal("design-node"),
+        fileKey: z.string().min(1),
+        nodeId: z.string().min(1).optional(),
+        variableKey: z.string().min(1).optional()
+    })
+]);
+/** How a fact was obtained. `llm-assisted` evidence is never allowed in adapter IR. */
+export const EXTRACTION_METHODS = [
+    "ast",
+    "compiler-api",
+    "metadata-parse",
+    "structured-parse",
+    "document-parse",
+    "llm-assisted",
+    "manual"
+];
+export const extractionMethodSchema = z.enum(EXTRACTION_METHODS);
+export const verificationStatusSchema = z.enum(["unverified", "verified", "contradicted"]);
+export const evidenceSchema = z.strictObject({
+    id: evidenceIdSchema,
+    sourceId: sourceIdSchema,
+    /** Source-native reference, for example `src/Button.tsx#Button` or a zeroheight page slug. */
+    sourceRef: z.string().min(1),
+    location: evidenceLocationSchema,
+    method: extractionMethodSchema,
+    extractor: z.strictObject({ name: z.string().min(1), version: z.string().min(1) }),
+    /** Bounded excerpt of the original source text. */
+    original: z.string().max(2000).optional(),
+    confidence: confidenceSchema.optional(),
+    verificationStatus: verificationStatusSchema,
+    capturedAt: isoTimestampSchema
+});
+export const evidenceFileSchema = z.strictObject({
+    evidenceVersion: z.literal(EVIDENCE_VERSION),
+    /** Content hash of the contract these evidence entries belong to. */
+    contractContentHash: sha256HexSchema,
+    evidence: z.array(evidenceSchema)
+});
+/**
+ * Evidence ids are content-addressed over the immutable parts of an observation. Confidence,
+ * verification status and capture time are mutable and deliberately excluded.
+ */
+export function computeEvidenceId(evidence) {
+    const digest = hashJson({
+        sourceId: evidence.sourceId,
+        sourceRef: evidence.sourceRef,
+        location: evidence.location,
+        method: evidence.method,
+        extractor: evidence.extractor,
+        original: evidence.original ?? null
+    });
+    return `ev_${digest.slice(0, 24)}`;
+}
+export function createEvidenceFile(contractContentHash, evidence) {
+    return {
+        evidenceVersion: EVIDENCE_VERSION,
+        contractContentHash,
+        evidence: [...evidence].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+    };
+}
+//# sourceMappingURL=evidence.js.map

package/dist/contract/fact-path.js

@@ -0,0 +1,39 @@
+/**
+ * Resolves a dotted fact path inside an entity. A segment addresses an object member, or, when the
+ * current node is an array, the item whose `name` (or else `id`) equals the segment, or else the
+ * item at that numeric index.
+ */
+export function resolveFactPath(entity, path) {
+    let node = entity;
+    for (const segment of path.split(".")) {
+        if (Array.isArray(node)) {
+            const item = node.find((candidate) => keyOf(candidate) === segment) ?? byIndex(node, segment);
+            if (item === undefined)
+                return { found: false };
+            node = item;
+        }
+        else if (isRecord(node) && Object.hasOwn(node, segment)) {
+            node = node[segment];
+        }
+        else {
+            return { found: false };
+        }
+    }
+    return node === undefined ? { found: false } : { found: true, value: node };
+}
+function keyOf(item) {
+    if (!isRecord(item))
+        return undefined;
+    if (typeof item.name === "string")
+        return item.name;
+    if (typeof item.id === "string")
+        return item.id;
+    return undefined;
+}
+function byIndex(items, segment) {
+    return /^\d+$/.test(segment) ? items[Number(segment)] : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=fact-path.js.map

package/dist/contract/facts.js

@@ -0,0 +1,62 @@
+import { hashJson } from "../shared/index.js";
+import { z } from "zod";
+import { evidenceIdSchema } from "./evidence.js";
+import { confidenceSchema, isoTimestampSchema, sha256HexSchema } from "./primitives.js";
+/**
+ * Epistemic status of a fact. Never collapsed into a confidence number:
+ * - discovered: parsed from an implementation artifact.
+ * - documented: stated by a person in documentation or a design tool.
+ * - inferred: derived by a named rule or model from other evidence.
+ * - approved: accepted by an authorized owner. Layers over `approval.priorStatus`, which is retained.
+ */
+export const factStatusSchema = z.enum(["discovered", "documented", "inferred", "approved"]);
+export const priorStatusSchema = z.enum(["discovered", "documented", "inferred"]);
+export const approvalSchema = z.strictObject({
+    approvedBy: z.string().min(1),
+    approvedAt: isoTimestampSchema,
+    role: z.string().min(1).optional(),
+    reference: z.string().min(1).optional(),
+    /** Hash of (entity id, path, value) at approval time. A mismatch means the approval is stale. */
+    fingerprint: sha256HexSchema,
+    priorStatus: priorStatusSchema
+});
+export const derivationSchema = z.strictObject({
+    rule: z.string().min(1),
+    reasoning: z.string().min(1),
+    inputs: z.array(z.string().min(1)),
+    model: z.strictObject({ id: z.string().min(1), promptHash: sha256HexSchema }).optional()
+});
+export const factRecordSchema = z
+    .strictObject({
+    status: factStatusSchema,
+    evidenceIds: z.array(evidenceIdSchema),
+    confidence: confidenceSchema.optional(),
+    derivation: derivationSchema.optional(),
+    approval: approvalSchema.optional()
+})
+    .superRefine((fact, ctx) => {
+    const issue = (message, path) => ctx.addIssue({ code: "custom", message, path });
+    if (fact.evidenceIds.length === 0)
+        issue("every fact needs at least one evidence id", ["evidenceIds"]);
+    if (fact.status === "approved") {
+        if (!fact.approval)
+            issue("approved facts require approval metadata", ["approval"]);
+    }
+    else if (fact.approval) {
+        issue("approval metadata is only valid when status is 'approved'", ["approval"]);
+    }
+    if (fact.status === "inferred") {
+        if (!fact.derivation)
+            issue("inferred facts require a derivation", ["derivation"]);
+        if (fact.confidence === undefined)
+            issue("inferred facts require a confidence", ["confidence"]);
+    }
+    else if (fact.derivation && fact.status !== "approved") {
+        issue("derivation is only valid on inferred or approved facts", ["derivation"]);
+    }
+});
+export const factsSchema = z.record(z.string(), factRecordSchema);
+export function computeFactFingerprint(input) {
+    return hashJson(input);
+}
+//# sourceMappingURL=facts.js.map

package/dist/contract/index.js

@@ -0,0 +1,16 @@
+export { effectiveParts } from "./archetype-checks.js";
+export { componentSchema } from "./components.js";
+export { conflictSchema } from "./conflicts.js";
+export { CONTRACT_VERSION, contractSchema, SUPPORTED_CONTRACT_VERSIONS } from "./contract.js";
+export { computeEvidenceId, createEvidenceFile, EVIDENCE_VERSION, EXTRACTION_METHODS, evidenceFileSchema, evidenceIdSchema, evidenceLocationSchema, evidenceSchema, extractionMethodSchema } from "./evidence.js";
+export { resolveFactPath } from "./fact-path.js";
+export { approvalSchema, computeFactFingerprint, factRecordSchema, factStatusSchema } from "./facts.js";
+export { computeContentHash, finalizeContract, serializeContract, serializeEvidenceFile } from "./integrity.js";
+export { contractJsonSchemas } from "./json-schema.js";
+export { constraintSchema, guidelineSchema, patternSchema, policySchema } from "./knowledge.js";
+export { ACYCLIC_RELATIONSHIPS, behaviorSchema, compositionPartSchema, constraintDetailsSchemas, EVIDENCE_LEVELS, elementRefSchema, evidenceLevelSchema, INTERACTION_STATES, interactionWorkflowSchema, isPatternConstraintKind, layoutRegionSchema, PATTERN_CATEGORIES, PATTERN_CATEGORIES_1_1, PATTERN_CONSTRAINT_KINDS, PATTERN_ONLY_RELATIONSHIPS, PATTERN_RELATIONSHIP_TYPES, partNameSchema, patternAccessibilitySchema, patternRelationshipSchema, patternVariationSchema, regionRefSchema, verifiableBySchema } from "./patterns.js";
+export { componentIdSchema, conflictIdSchema, ENTITY_KINDS, entityIdSchema, entityIdSchemaFor, FRAMEWORKS, factPathSchema, frameworkSchema, jsonValueSchema, relativePathSchema, SOURCE_TYPES, sourceIdSchema, sourceTypeSchema, themeIdSchema, tokenIdSchema } from "./primitives.js";
+export { sourceSchema, sourceVersionSchema } from "./sources.js";
+export { TOKEN_CATEGORIES, themeSchema, tokenSchema } from "./tokens.js";
+export { parseContract, verifyContract } from "./validate.js";
+//# sourceMappingURL=index.js.map

package/dist/contract/integrity.js

@@ -0,0 +1,21 @@
+import { canonicalStringify, hashJson } from "../shared/index.js";
+/**
+ * The content hash covers everything except the integrity block and volatile timestamps
+ * (`metadata.compiledAt`, `sources[].lastSyncedAt`), so recompiling unchanged inputs yields the same hash.
+ */
+export function computeContentHash(contract) {
+    const { integrity: _integrity, ...body } = contract;
+    const { compiledAt: _compiledAt, ...metadata } = body.metadata;
+    const sources = body.sources.map(({ lastSyncedAt: _lastSyncedAt, ...source }) => source);
+    return hashJson({ ...body, metadata, sources });
+}
+export function finalizeContract(draft) {
+    return { ...draft, integrity: { algorithm: "sha256", contentHash: computeContentHash(draft) } };
+}
+export function serializeContract(contract) {
+    return `${canonicalStringify(contract, 2)}\n`;
+}
+export function serializeEvidenceFile(file) {
+    return `${canonicalStringify(file, 2)}\n`;
+}
+//# sourceMappingURL=integrity.js.map

package/dist/contract/json-schema.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+import { contractSchema } from "./contract.js";
+import { evidenceFileSchema } from "./evidence.js";
+/** Serialized-contract JSON Schemas, derived from the Zod definitions (the single source of truth). */
+export function contractJsonSchemas() {
+    return {
+        "contract-v1.schema.json": { title: "Invariant contract v1", ...z.toJSONSchema(contractSchema) },
+        "evidence-v1.schema.json": { title: "Invariant evidence file v1", ...z.toJSONSchema(evidenceFileSchema) }
+    };
+}
+//# sourceMappingURL=json-schema.js.map