@comity-dev/schemas 0.1.1 → 0.3.0

package/README.md

@@ -7,7 +7,7 @@ Canonical, machine-readable JSON Schema definitions for Comity package metadata,
 ## Scope
 
 - `package-metadata.v1.json` — required fields and types for every `@comity/*` package's `package.json` (`name`, `version`, `type`, `license`, `engines`, `exports`, `comity.layer`, `comity.implements`).
-- ADR-008 register schema — machine-readable composition exception register.
+- ADR-008 register schema and register — the canonical JSON Schema 2020-12 document and register from `docs/standards/decisions/data/`, embedded at build time (`pnpm --filter @comity-dev/schemas generate`); `adr008CoreExceptionRegister` is derived, never hand-edited. Compile with `createAjv2020Instance()`.
 - `comity-config.json` schema — repository-level configuration shape.
 
 ## Ownership

package/dist/ajv-instance.d.ts

@@ -0,0 +1,17 @@
+import Ajv from "ajv";
+import Ajv2020 from "ajv/dist/2020.js";
+/**
+ * Creates a fresh Ajv instance with strict settings and standard formats.
+ *
+ * @returns Configured Ajv instance
+ */
+export declare function createAjvInstance(): Ajv;
+/**
+ * Creates a fresh Ajv instance for JSON Schema draft 2020-12 documents, such
+ * as the canonical ADR-008 register schema. Separate from
+ * {@link createAjvInstance} so the draft-07 package-metadata and config
+ * schemas are unaffected.
+ *
+ * @returns Configured Ajv 2020-12 instance
+ */
+export declare function createAjv2020Instance(): Ajv2020;

package/dist/ajv-instance.js

@@ -0,0 +1,36 @@
+import Ajv from "ajv";
+import Ajv2020 from "ajv/dist/2020.js";
+import addFormats from "ajv-formats";
+/**
+ * Creates a fresh Ajv instance with strict settings and standard formats.
+ *
+ * @returns Configured Ajv instance
+ */
+export function createAjvInstance() {
+    const ajv = new Ajv({
+        allErrors: true,
+        strict: false,
+        strictTypes: false,
+        verbose: true,
+    });
+    addFormats(ajv);
+    return ajv;
+}
+/**
+ * Creates a fresh Ajv instance for JSON Schema draft 2020-12 documents, such
+ * as the canonical ADR-008 register schema. Separate from
+ * {@link createAjvInstance} so the draft-07 package-metadata and config
+ * schemas are unaffected.
+ *
+ * @returns Configured Ajv 2020-12 instance
+ */
+export function createAjv2020Instance() {
+    const ajv = new Ajv2020({
+        allErrors: true,
+        strict: false,
+        strictTypes: false,
+        verbose: true,
+    });
+    addFormats(ajv);
+    return ajv;
+}

package/dist/constants.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Canonical Comity constants.
+ *
+ * These values are derived from the authoritative Comity Standards
+ * (layering-policy.md, ADR-026). They MUST be kept in sync with those
+ * documents; updating them here implies updating the standards.
+ *
+ * @see layering-policy.md §2.1 / ADR-026 (package classification)
+ *
+ * ADR-026 defines `comity.layer` as the architecture classification of
+ * Comity RUNTIME packages (`@comity/*`). The six runtime layers are:
+ *
+ *   primitives, kernel, composition, core,
+ *   technology-adapter, integration-adapter
+ *
+ * `dev-tooling` is a reserved Development-side extension for
+ * `@comity-dev/*` packages only. It is NOT a seventh runtime layer
+ * and MUST NOT be used by `@comity/*` packages. The name-scope ↔
+ * layer boundary is enforced by the package-metadata JSON Schema
+ * (`schemas/package-metadata.ts`).
+ *
+ * Rationale for the extension: Development tooling packages
+ * legitimately use Node APIs, `process.env`, and other patterns that
+ * the runtime Semgrep and ESLint rules forbid. Declaring `dev-tooling`
+ * on these packages lets the validator engines (semgrep, depcruise,
+ * eslint, adapter-peers) scope those rules away from them. The
+ * runtime six-layer model is unchanged.
+ */
+export declare const RUNTIME_LAYERS: readonly string[];
+/**
+ * All layer values accepted by `comity.layer`. The boundary between
+ * runtime and development layers is enforced by the schema, not by
+ * this list alone.
+ */
+export declare const VALID_LAYERS: readonly string[];
+/**
+ * @see ADR-026 (package naming)
+ *      architecture-validation.md §8
+ */
+export declare const PACKAGE_NAME_PATTERN = "^@comity(-dev)?/[a-z0-9]+(?:-[a-z0-9]+)*$";
+/**
+ * @see architecture-validation.md §8 (metadata — engines.node minimum)
+ */
+export declare const MIN_NODE_VERSION = "24.0.0";

package/dist/constants.js

@@ -0,0 +1,54 @@
+/**
+ * Canonical Comity constants.
+ *
+ * These values are derived from the authoritative Comity Standards
+ * (layering-policy.md, ADR-026). They MUST be kept in sync with those
+ * documents; updating them here implies updating the standards.
+ *
+ * @see layering-policy.md §2.1 / ADR-026 (package classification)
+ *
+ * ADR-026 defines `comity.layer` as the architecture classification of
+ * Comity RUNTIME packages (`@comity/*`). The six runtime layers are:
+ *
+ *   primitives, kernel, composition, core,
+ *   technology-adapter, integration-adapter
+ *
+ * `dev-tooling` is a reserved Development-side extension for
+ * `@comity-dev/*` packages only. It is NOT a seventh runtime layer
+ * and MUST NOT be used by `@comity/*` packages. The name-scope ↔
+ * layer boundary is enforced by the package-metadata JSON Schema
+ * (`schemas/package-metadata.ts`).
+ *
+ * Rationale for the extension: Development tooling packages
+ * legitimately use Node APIs, `process.env`, and other patterns that
+ * the runtime Semgrep and ESLint rules forbid. Declaring `dev-tooling`
+ * on these packages lets the validator engines (semgrep, depcruise,
+ * eslint, adapter-peers) scope those rules away from them. The
+ * runtime six-layer model is unchanged.
+ */
+export const RUNTIME_LAYERS = Object.freeze([
+    "primitives",
+    "kernel",
+    "composition",
+    "core",
+    "technology-adapter",
+    "integration-adapter",
+]);
+/**
+ * All layer values accepted by `comity.layer`. The boundary between
+ * runtime and development layers is enforced by the schema, not by
+ * this list alone.
+ */
+export const VALID_LAYERS = Object.freeze([
+    ...RUNTIME_LAYERS,
+    "dev-tooling",
+]);
+/**
+ * @see ADR-026 (package naming)
+ *      architecture-validation.md §8
+ */
+export const PACKAGE_NAME_PATTERN = "^@comity(-dev)?/[a-z0-9]+(?:-[a-z0-9]+)*$";
+/**
+ * @see architecture-validation.md §8 (metadata — engines.node minimum)
+ */
+export const MIN_NODE_VERSION = "24.0.0";

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export type { Adr008Register, Adr008RegisterEdge, } from "./schemas/adr-008-register.js";
+export type { ComityConfig } from "./schemas/comity-config.js";
+export type { PackageMetadata, ValidationResult, } from "./schemas/package-metadata.js";
+export { createAjv2020Instance, createAjvInstance } from "./ajv-instance.js";
+export { MIN_NODE_VERSION, PACKAGE_NAME_PATTERN, RUNTIME_LAYERS, VALID_LAYERS, } from "./constants.js";
+export { adr008CoreExceptionRegister, adr008RegisterSchema, validateAdr008Register, } from "./schemas/adr-008-register.js";
+export { comityConfigSchema, validateComityConfig, } from "./schemas/comity-config.js";
+export { packageMetadataSchema, validatePackageMetadata, } from "./schemas/package-metadata.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { createAjv2020Instance, createAjvInstance } from "./ajv-instance.js";
+export { MIN_NODE_VERSION, PACKAGE_NAME_PATTERN, RUNTIME_LAYERS, VALID_LAYERS, } from "./constants.js";
+export { adr008CoreExceptionRegister, adr008RegisterSchema, validateAdr008Register, } from "./schemas/adr-008-register.js";
+export { comityConfigSchema, validateComityConfig, } from "./schemas/comity-config.js";
+export { packageMetadataSchema, validatePackageMetadata, } from "./schemas/package-metadata.js";

package/dist/schemas/adr-008-canonical.generated.d.ts

@@ -0,0 +1,3 @@
+import type { Adr008Register } from "./adr-008-register.js";
+export declare const adr008RegisterSchemaDocument: Record<string, unknown>;
+export declare const adr008CanonicalRegister: Adr008Register;

package/dist/schemas/adr-008-canonical.generated.js

@@ -0,0 +1,390 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: docs/standards/decisions/data/adr-008-core-exception-register{,.schema}.json
+// Regenerate with: pnpm --filter @comity-dev/schemas generate
+export const adr008RegisterSchemaDocument = {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "comity:adr-008-core-exception-register.schema.json",
+    "title": "ADR-008 Core-to-Core Dependency Exception Register",
+    "description": "Machine-readable serialization of the ADR-008 closed register of Core-to-Core dependency exceptions. ADR-008 (Markdown) remains the architectural authority; this register is a derived representation and MUST NOT redefine architecture.",
+    "type": "object",
+    "additionalProperties": false,
+    "required": [
+        "$schema",
+        "schemaVersion",
+        "authority",
+        "source",
+        "edges"
+    ],
+    "properties": {
+        "$schema": {
+            "const": "comity:adr-008-core-exception-register.schema.json"
+        },
+        "schemaVersion": {
+            "type": "integer",
+            "const": 1,
+            "description": "Version of the register schema. Incremented when the data contract changes in a breaking way."
+        },
+        "authority": {
+            "const": "ADR-008",
+            "description": "The architectural authority this register serializes."
+        },
+        "source": {
+            "const": "../ADR-008-explicit-core-module-composition-exceptions.md",
+            "description": "Path to the authoritative ADR document, relative to the register file (the ADR lives in the parent directory of data/)."
+        },
+        "edges": {
+            "type": "array",
+            "description": "Closed list of approved Core-to-Core dependency exceptions.",
+            "items": {
+                "$ref": "#/$defs/dependencyEdge"
+            },
+            "uniqueItems": true
+        }
+    },
+    "$defs": {
+        "dependencyEdge": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+                "from",
+                "to",
+                "layer",
+                "categories",
+                "importKind",
+                "lifecycle",
+                "justification",
+                "adrReference"
+            ],
+            "properties": {
+                "from": {
+                    "type": "string",
+                    "pattern": "^@comity/[a-z0-9-]+$",
+                    "description": "Source package name."
+                },
+                "to": {
+                    "type": "string",
+                    "pattern": "^@comity/[a-z0-9-]+$",
+                    "description": "Target package name."
+                },
+                "layer": {
+                    "const": "core-to-core",
+                    "description": "Layer relationship. This register covers only Core-to-Core edges."
+                },
+                "categories": {
+                    "type": "array",
+                    "minItems": 1,
+                    "uniqueItems": true,
+                    "items": {
+                        "type": "string",
+                        "enum": [
+                            "capability",
+                            "infrastructure-contract",
+                            "value-import",
+                            "candidate-for-removal"
+                        ]
+                    },
+                    "description": "All classifications that apply to this edge. A single edge may belong to multiple classifications (e.g., storefront -> catalog is both a capability exception and a value-import exception). This is the sole classification field."
+                },
+                "importKind": {
+                    "type": "string",
+                    "enum": [
+                        "type-only",
+                        "value",
+                        "mixed"
+                    ],
+                    "description": "Whether the dependency is type-only, value, or a mix of both."
+                },
+                "lifecycle": {
+                    "type": "string",
+                    "enum": [
+                        "approved",
+                        "deprecated",
+                        "migration-candidate"
+                    ],
+                    "description": "Lifecycle status: approved exception, deprecated pattern tracked for removal, or scheduled migration candidate."
+                },
+                "justification": {
+                    "type": "string",
+                    "minLength": 1,
+                    "description": "Justification as recorded in ADR-008."
+                },
+                "adrReference": {
+                    "type": "string",
+                    "minLength": 1,
+                    "description": "Reference back to ADR-008, including the specific register section/table where practical."
+                },
+                "removalCandidate": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": [
+                        "criteria",
+                        "action"
+                    ],
+                    "description": "Removal candidate tracking, mirroring ADR-008 'Candidates for Removal'. Required when lifecycle is 'migration-candidate'.",
+                    "properties": {
+                        "criteria": {
+                            "type": "string",
+                            "description": "The ADR-008 acceptance criteria this dependency fails."
+                        },
+                        "action": {
+                            "type": "string",
+                            "description": "The migration action required to remove or refactor the dependency."
+                        }
+                    }
+                }
+            },
+            "if": {
+                "properties": {
+                    "lifecycle": {
+                        "const": "migration-candidate"
+                    }
+                },
+                "required": [
+                    "lifecycle"
+                ]
+            },
+            "then": {
+                "required": [
+                    "removalCandidate"
+                ]
+            }
+        }
+    }
+};
+export const adr008CanonicalRegister = {
+    "$schema": "comity:adr-008-core-exception-register.schema.json",
+    "schemaVersion": 1,
+    "authority": "ADR-008",
+    "source": "../ADR-008-explicit-core-module-composition-exceptions.md",
+    "edges": [
+        {
+            "from": "@comity/storefront",
+            "to": "@comity/catalog",
+            "layer": "core-to-core",
+            "categories": [
+                "capability"
+            ],
+            "importKind": "type-only",
+            "lifecycle": "approved",
+            "justification": "Storefront page composition references catalog domain contracts and models.",
+            "adrReference": "ADR-008 — Dependency Register, Capability Exceptions"
+        },
+        {
+            "from": "@comity/storefront",
+            "to": "@comity/taxonomy",
+            "layer": "core-to-core",
+            "categories": [
+                "capability"
+            ],
+            "importKind": "type-only",
+            "lifecycle": "approved",
+            "justification": "Storefront category page composition references taxonomy domain contracts and models.",
+            "adrReference": "ADR-008 — Dependency Register, Capability Exceptions"
+        },
+        {
+            "from": "@comity/storefront",
+            "to": "@comity/content",
+            "layer": "core-to-core",
+            "categories": [
+                "capability"
+            ],
+            "importKind": "type-only",
+            "lifecycle": "approved",
+            "justification": "Storefront content page composer references content domain models.",
+            "adrReference": "ADR-008 — Dependency Register, Capability Exceptions"
+        },
+        {
+            "from": "@comity/storefront",
+            "to": "@comity/search",
+            "layer": "core-to-core",
+            "categories": [
+                "capability"
+            ],
+            "importKind": "type-only",
+            "lifecycle": "approved",
+            "justification": "Storefront search page contract references SearchResultModel.",
+            "adrReference": "ADR-008 — Dependency Register, Capability Exceptions"
+        },
+        {
+            "from": "@comity/catalog",
+            "to": "@comity/media",
+            "layer": "core-to-core",
+            "categories": [
+                "capability"
+            ],
+            "importKind": "type-only",
+            "lifecycle": "approved",
+            "justification": "Catalog projections reference MediaModel for product/brand media.",
+            "adrReference": "ADR-008 — Dependency Register, Capability Exceptions"
+        },
+        {
+            "from": "@comity/content",
+            "to": "@comity/media",
+            "layer": "core-to-core",
+            "categories": [
+                "capability"
+            ],
+            "importKind": "type-only",
+            "lifecycle": "approved",
+            "justification": "Content blocks/pages reference MediaModel.",
+            "adrReference": "ADR-008 — Dependency Register, Capability Exceptions"
+        },
+        {
+            "from": "@comity/content",
+            "to": "@comity/seo",
+            "layer": "core-to-core",
+            "categories": [
+                "capability"
+            ],
+            "importKind": "type-only",
+            "lifecycle": "approved",
+            "justification": "Content pages reference SeoModel.",
+            "adrReference": "ADR-008 — Dependency Register, Capability Exceptions"
+        },
+        {
+            "from": "@comity/taxonomy",
+            "to": "@comity/media",
+            "layer": "core-to-core",
+            "categories": [
+                "capability"
+            ],
+            "importKind": "type-only",
+            "lifecycle": "approved",
+            "justification": "Taxonomy models reference MediaModel for category image.",
+            "adrReference": "ADR-008 — Dependency Register, Capability Exceptions"
+        },
+        {
+            "from": "@comity/order",
+            "to": "@comity/pricing",
+            "layer": "core-to-core",
+            "categories": [
+                "capability",
+                "value-import"
+            ],
+            "importKind": "value",
+            "lifecycle": "approved",
+            "justification": "@comity/order composes its order-level PriceRecord via the public PriceRecord type and combine (record composition, not calculation); the record type stays pricing-owned.",
+            "adrReference": "ADR-008 — Dependency Register, Capability Exceptions"
+        },
+        {
+            "from": "@comity/order",
+            "to": "@comity/organization",
+            "layer": "core-to-core",
+            "categories": [
+                "capability"
+            ],
+            "importKind": "type-only",
+            "lifecycle": "approved",
+            "justification": "Order contracts reference ChannelId for commercial channel scoping.",
+            "adrReference": "ADR-008 — Dependency Register, Capability Exceptions"
+        },
+        {
+            "from": "@comity/fulfillment",
+            "to": "@comity/order",
+            "layer": "core-to-core",
+            "categories": [
+                "capability"
+            ],
+            "importKind": "type-only",
+            "lifecycle": "approved",
+            "justification": "Fulfillment references the committed order by OrderId and reuses the OrderAddressSnapshot contract for shipping recipients; it never holds an Order and imports no value from @comity/order.",
+            "adrReference": "ADR-008 — Amendment 2, Capability Exceptions"
+        },
+        {
+            "from": "@comity/fulfillment",
+            "to": "@comity/organization",
+            "layer": "core-to-core",
+            "categories": [
+                "capability"
+            ],
+            "importKind": "type-only",
+            "lifecycle": "approved",
+            "justification": "Fulfillment repository contracts require TenantId for multi-tenant isolation, as order and customer repositories do.",
+            "adrReference": "ADR-008 — Amendment 2, Capability Exceptions"
+        },
+        {
+            "from": "@comity/customer",
+            "to": "@comity/validation",
+            "layer": "core-to-core",
+            "categories": [
+                "capability"
+            ],
+            "importKind": "type-only",
+            "lifecycle": "approved",
+            "justification": "Customer validator consumes the shared Validator contract.",
+            "adrReference": "ADR-008 — Dependency Register, Capability Exceptions"
+        },
+        {
+            "from": "@comity/customer",
+            "to": "@comity/organization",
+            "layer": "core-to-core",
+            "categories": [
+                "capability"
+            ],
+            "importKind": "type-only",
+            "lifecycle": "approved",
+            "justification": "Customer repository requires TenantId for multi-tenant isolation.",
+            "adrReference": "ADR-008 — Dependency Register, Capability Exceptions"
+        },
+        {
+            "from": "@comity/address",
+            "to": "@comity/validation",
+            "layer": "core-to-core",
+            "categories": [
+                "capability"
+            ],
+            "importKind": "type-only",
+            "lifecycle": "approved",
+            "justification": "Address validator consumes the shared Validator contract.",
+            "adrReference": "ADR-008 — Dependency Register, Capability Exceptions"
+        },
+        {
+            "from": "@comity/identity",
+            "to": "@comity/validation",
+            "layer": "core-to-core",
+            "categories": [
+                "capability"
+            ],
+            "importKind": "type-only",
+            "lifecycle": "approved",
+            "justification": "Identity validator consumes the shared Validator contract.",
+            "adrReference": "ADR-008 — Dependency Register, Capability Exceptions"
+        },
+        {
+            "from": "@comity/auth-tokens",
+            "to": "@comity/auth",
+            "layer": "core-to-core",
+            "categories": [
+                "value-import"
+            ],
+            "importKind": "mixed",
+            "lifecycle": "approved",
+            "justification": "Token facade error surface normalizes AuthError at runtime. @comity/auth owns authentication error semantics; direction is intentional and non-cyclic.",
+            "adrReference": "ADR-008 — Dependency Register, Value-Import Exceptions"
+        },
+        {
+            "from": "@comity/router",
+            "to": "@comity/http",
+            "layer": "core-to-core",
+            "categories": [
+                "infrastructure-contract"
+            ],
+            "importKind": "type-only",
+            "lifecycle": "deprecated",
+            "justification": "Router contracts reference HttpContext, HttpHandler, HttpMethod. Compatibility exception; extraction candidate.",
+            "adrReference": "ADR-008 — Dependency Register, Infrastructure Contract Exceptions"
+        },
+        {
+            "from": "@comity/payment",
+            "to": "@comity/pricing",
+            "layer": "core-to-core",
+            "categories": [
+                "capability"
+            ],
+            "importKind": "type-only",
+            "lifecycle": "approved",
+            "justification": "Payment module uses Money value object from pricing for amount representation in PaymentRequest and PaymentOutcome.",
+            "adrReference": "ADR-008 — Dependency Register, Capability Exceptions"
+        }
+    ]
+};

package/dist/schemas/adr-008-register.d.ts

@@ -0,0 +1,52 @@
+import type { Ajv, ErrorObject } from "ajv";
+/**
+ * Canonical schema for the ADR-008 Core Exception Register.
+ *
+ * Derived at build time from the canonical JSON Schema
+ * `docs/standards/decisions/data/adr-008-core-exception-register.schema.json`
+ * (ADR-009 §3, §5). It is a JSON Schema 2020-12 document, so it must be
+ * compiled with {@link createAjv2020Instance}.
+ *
+ * @see ADR-008 — Explicit Core Module Composition Exceptions
+ * @see ADR-009 — Machine-Readable Core Exception Register
+ */
+export declare const adr008RegisterSchema: Record<string, unknown>;
+/**
+ * Canonical ADR-008 register, derived at build time from
+ * `docs/standards/decisions/data/adr-008-core-exception-register.json`.
+ * ADR-008 (Markdown) remains the architectural authority.
+ */
+export declare const adr008CoreExceptionRegister: Adr008Register;
+/**
+ * Validates a parsed ADR-008 register document against the canonical schema.
+ *
+ * @param document — parsed ADR-008 register
+ * @param ajv — optional pre-built Ajv instance; it MUST support JSON Schema
+ *   2020-12 (use {@link createAjv2020Instance})
+ * @returns validation result
+ */
+export declare function validateAdr008Register(document: unknown, ajv?: Ajv): {
+    valid: boolean;
+    errors: ErrorObject[];
+};
+export interface Adr008RegisterEdge {
+    from: string;
+    to: string;
+    layer: string;
+    categories: string[];
+    importKind: string;
+    lifecycle: string;
+    justification: string;
+    adrReference: string;
+    removalCandidate?: {
+        criteria: string;
+        action: string;
+    };
+}
+export interface Adr008Register {
+    $schema: string;
+    schemaVersion: number;
+    authority: string;
+    source: string;
+    edges: Adr008RegisterEdge[];
+}

package/dist/schemas/adr-008-register.js

@@ -0,0 +1,37 @@
+import { createAjv2020Instance } from "../ajv-instance.js";
+import { adr008CanonicalRegister, adr008RegisterSchemaDocument, } from "./adr-008-canonical.generated.js";
+/**
+ * Canonical schema for the ADR-008 Core Exception Register.
+ *
+ * Derived at build time from the canonical JSON Schema
+ * `docs/standards/decisions/data/adr-008-core-exception-register.schema.json`
+ * (ADR-009 §3, §5). It is a JSON Schema 2020-12 document, so it must be
+ * compiled with {@link createAjv2020Instance}.
+ *
+ * @see ADR-008 — Explicit Core Module Composition Exceptions
+ * @see ADR-009 — Machine-Readable Core Exception Register
+ */
+export const adr008RegisterSchema = adr008RegisterSchemaDocument;
+/**
+ * Canonical ADR-008 register, derived at build time from
+ * `docs/standards/decisions/data/adr-008-core-exception-register.json`.
+ * ADR-008 (Markdown) remains the architectural authority.
+ */
+export const adr008CoreExceptionRegister = adr008CanonicalRegister;
+/**
+ * Validates a parsed ADR-008 register document against the canonical schema.
+ *
+ * @param document — parsed ADR-008 register
+ * @param ajv — optional pre-built Ajv instance; it MUST support JSON Schema
+ *   2020-12 (use {@link createAjv2020Instance})
+ * @returns validation result
+ */
+export function validateAdr008Register(document, ajv = createAjv2020Instance()) {
+    const id = adr008RegisterSchema["$id"];
+    const validate = ajv.getSchema(id) ?? ajv.compile(adr008RegisterSchema);
+    const valid = validate(document);
+    return {
+        valid: Boolean(valid),
+        errors: valid ? [] : (validate.errors ?? []),
+    };
+}

package/dist/schemas/comity-config.d.ts

@@ -0,0 +1,163 @@
+import type { Ajv, ErrorObject } from "ajv";
+/**
+ * Canonical schema for repository `comity.config.json`.
+ *
+ * The configuration holds REPOSITORY FACTS — package locations, repository
+ * type, declared exceptions. It MUST NOT silently redefine Comity-wide
+ * policy; policy belongs in the Standards and is enforced by shared tools.
+ *
+ * @see layering-policy.md (policy owner)
+ * @see ADR-007 (integration-adapter vs technology-adapter categorization)
+ */
+export declare const comityConfigSchema: {
+    $id: string;
+    type: string;
+    additionalProperties: boolean;
+    required: string[];
+    properties: {
+        repository: {
+            type: string;
+            required: string[];
+            additionalProperties: boolean;
+            properties: {
+                name: {
+                    type: string;
+                    minLength: number;
+                    description: string;
+                };
+                type: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+            };
+        };
+        packages: {
+            type: string;
+            required: string[];
+            additionalProperties: boolean;
+            properties: {
+                roots: {
+                    type: string;
+                    items: {
+                        type: string;
+                        minLength: number;
+                    };
+                    minItems: number;
+                    description: string;
+                };
+                exclude: {
+                    type: string;
+                    items: {
+                        type: string;
+                        minLength: number;
+                    };
+                    description: string;
+                };
+            };
+        };
+        validation: {
+            type: string;
+            additionalProperties: boolean;
+            properties: {
+                rules: {
+                    type: string;
+                    description: string;
+                    additionalProperties: {
+                        type: string;
+                    };
+                };
+                exceptions: {
+                    type: string;
+                    additionalProperties: boolean;
+                    properties: {
+                        dependencyEdges: {
+                            type: string;
+                            description: string;
+                            items: {
+                                type: string;
+                                required: string[];
+                                properties: {
+                                    from: {
+                                        type: string;
+                                    };
+                                    to: {
+                                        type: string;
+                                    };
+                                    adr: {
+                                        type: string;
+                                    };
+                                    rationale: {
+                                        type: string;
+                                    };
+                                };
+                                additionalProperties: boolean;
+                            };
+                        };
+                        layerOverrides: {
+                            type: string;
+                            description: string;
+                            items: {
+                                type: string;
+                                required: string[];
+                                properties: {
+                                    package: {
+                                        type: string;
+                                    };
+                                    layer: {
+                                        type: string;
+                                    };
+                                    adr: {
+                                        type: string;
+                                    };
+                                    rationale: {
+                                        type: string;
+                                    };
+                                };
+                                additionalProperties: boolean;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+/**
+ * Validates a parsed comity.config.json document.
+ *
+ * @param document — parsed comity.config.json
+ * @param ajv — optional pre-built Ajv instance
+ * @returns validation result
+ */
+export declare function validateComityConfig(document: unknown, ajv?: Ajv): {
+    valid: boolean;
+    errors: ErrorObject[];
+};
+export interface ComityConfig {
+    repository: {
+        name: string;
+        type: string;
+    };
+    packages: {
+        roots: string[];
+        exclude?: string[];
+    };
+    validation?: {
+        rules?: Record<string, boolean>;
+        exceptions?: {
+            dependencyEdges?: Array<{
+                from: string;
+                to: string;
+                adr: string;
+                rationale?: string;
+            }>;
+            layerOverrides?: Array<{
+                package: string;
+                layer: string;
+                adr: string;
+                rationale?: string;
+            }>;
+        };
+    };
+}

package/dist/schemas/comity-config.js

@@ -0,0 +1,122 @@
+import { createAjvInstance } from "../ajv-instance.js";
+/**
+ * Canonical schema for repository `comity.config.json`.
+ *
+ * The configuration holds REPOSITORY FACTS — package locations, repository
+ * type, declared exceptions. It MUST NOT silently redefine Comity-wide
+ * policy; policy belongs in the Standards and is enforced by shared tools.
+ *
+ * @see layering-policy.md (policy owner)
+ * @see ADR-007 (integration-adapter vs technology-adapter categorization)
+ */
+export const comityConfigSchema = {
+    $id: "https://comityjs.dev/schemas/comity-config.v1.json",
+    type: "object",
+    additionalProperties: false,
+    required: ["repository", "packages"],
+    properties: {
+        repository: {
+            type: "object",
+            required: ["name", "type"],
+            additionalProperties: false,
+            properties: {
+                name: {
+                    type: "string",
+                    minLength: 1,
+                    description: "Logical name of the repository.",
+                },
+                type: {
+                    type: "string",
+                    enum: [
+                        "development",
+                        "community",
+                        "enterprise",
+                        "third-party",
+                        "fixture",
+                    ],
+                    description: "Repository category.",
+                },
+            },
+        },
+        packages: {
+            type: "object",
+            required: ["roots"],
+            additionalProperties: false,
+            properties: {
+                roots: {
+                    type: "array",
+                    items: { type: "string", minLength: 1 },
+                    minItems: 1,
+                    description: "Workspace package roots, relative to the repository root.",
+                },
+                exclude: {
+                    type: "array",
+                    items: { type: "string", minLength: 1 },
+                    description: "Package path patterns to exclude from validation.",
+                },
+            },
+        },
+        validation: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                rules: {
+                    type: "object",
+                    description: "Repository-specific rule selection. Allowed keys: metadata, dependencies, eslint, semgrep, orchestrator.",
+                    additionalProperties: { type: "boolean" },
+                },
+                exceptions: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        dependencyEdges: {
+                            type: "array",
+                            description: "Locally-permitted dependency edges. Each entry MUST reference an ADR.",
+                            items: {
+                                type: "object",
+                                required: ["from", "to", "adr"],
+                                properties: {
+                                    from: { type: "string" },
+                                    to: { type: "string" },
+                                    adr: { type: "string" },
+                                    rationale: { type: "string" },
+                                },
+                                additionalProperties: false,
+                            },
+                        },
+                        layerOverrides: {
+                            type: "array",
+                            description: "Layer classification overrides — for transitional packages only.",
+                            items: {
+                                type: "object",
+                                required: ["package", "layer", "adr"],
+                                properties: {
+                                    package: { type: "string" },
+                                    layer: { type: "string" },
+                                    adr: { type: "string" },
+                                    rationale: { type: "string" },
+                                },
+                                additionalProperties: false,
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+};
+/**
+ * Validates a parsed comity.config.json document.
+ *
+ * @param document — parsed comity.config.json
+ * @param ajv — optional pre-built Ajv instance
+ * @returns validation result
+ */
+export function validateComityConfig(document, ajv = createAjvInstance()) {
+    const validate = ajv.compile(comityConfigSchema);
+    const valid = validate(document);
+    return {
+        valid: Boolean(valid),
+        errors: valid ? [] : (validate.errors ?? []),
+    };
+}

package/dist/schemas/index.d.ts

@@ -0,0 +1,6 @@
+export type { Adr008Register, Adr008RegisterEdge, } from "./adr-008-register.js";
+export type { ComityConfig } from "./comity-config.js";
+export type { PackageMetadata, ValidationResult } from "./package-metadata.js";
+export { adr008CoreExceptionRegister, adr008RegisterSchema, validateAdr008Register, } from "./adr-008-register.js";
+export { comityConfigSchema, validateComityConfig } from "./comity-config.js";
+export { packageMetadataSchema, validatePackageMetadata, } from "./package-metadata.js";

package/dist/schemas/index.js

@@ -0,0 +1,3 @@
+export { adr008CoreExceptionRegister, adr008RegisterSchema, validateAdr008Register, } from "./adr-008-register.js";
+export { comityConfigSchema, validateComityConfig } from "./comity-config.js";
+export { packageMetadataSchema, validatePackageMetadata, } from "./package-metadata.js";

package/dist/schemas/package-metadata.d.ts

@@ -0,0 +1,157 @@
+import type { Ajv, ErrorObject } from "ajv";
+/**
+ * Canonical schema for Comity package metadata.
+ *
+ * Covers both namespaces, with a name-scope ↔ layer boundary:
+ *   - `@comity/*` (runtime)     → `comity.layer` MUST be one of the six
+ *                                 runtime layers (ADR-026).
+ *   - `@comity-dev/*` (tooling) → `comity.layer` MUST be `dev-tooling`.
+ *
+ * The boundary is enforced by the `if/then/else` clause on `comity.layer`.
+ *
+ * @see ADR-026 — Architecture Validator Authoritative Classification
+ * @see layering-policy.md §2.1
+ * @see architecture-validation.md §8 (package naming, type, engines.node)
+ * @see public-api.md §3 (exports subpath rules)
+ *
+ * This schema is the authoritative machine-readable definition of what every
+ * Comity package manifest MUST contain. Repositories consume this schema via
+ * the shared `comity-validate` orchestrator; they do not redefine it.
+ */
+export declare const packageMetadataSchema: {
+    $id: string;
+    type: string;
+    required: string[];
+    additionalProperties: boolean;
+    properties: {
+        name: {
+            type: string;
+            pattern: string;
+            description: string;
+        };
+        version: {
+            type: string;
+            pattern: string;
+            description: string;
+        };
+        type: {
+            const: string;
+            description: string;
+        };
+        license: {
+            type: string;
+            minLength: number;
+            description: string;
+        };
+        engines: {
+            type: string;
+            required: string[];
+            properties: {
+                node: {
+                    type: string;
+                    pattern: string;
+                    description: string;
+                };
+            };
+            additionalProperties: boolean;
+        };
+        comity: {
+            type: string;
+            description: string;
+            required: string[];
+            properties: {
+                layer: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                implements: {
+                    type: string;
+                    pattern: string;
+                    description: string;
+                };
+            };
+            additionalProperties: boolean;
+        };
+        exports: {
+            type: string;
+            description: string;
+            additionalProperties: boolean;
+        };
+        typesVersions: {
+            type: string;
+            description: string;
+            additionalProperties: boolean;
+        };
+    };
+    allOf: ({
+        if: {
+            properties: {
+                name: {
+                    pattern: string;
+                };
+            };
+            required: string[];
+        };
+        then: {
+            properties: {
+                comity: {
+                    properties: {
+                        layer: {
+                            enum: string[];
+                            const?: never;
+                        };
+                    };
+                };
+            };
+        };
+    } | {
+        if: {
+            properties: {
+                name: {
+                    pattern: string;
+                };
+            };
+            required: string[];
+        };
+        then: {
+            properties: {
+                comity: {
+                    properties: {
+                        layer: {
+                            const: string;
+                            enum?: never;
+                        };
+                    };
+                };
+            };
+        };
+    })[];
+};
+/**
+ * Validates a parsed package.json against the canonical schema.
+ *
+ * @param manifest — parsed package.json object
+ * @param ajv — optional pre-built Ajv instance
+ * @returns validation result
+ */
+export declare function validatePackageMetadata(manifest: unknown, ajv?: Ajv): ValidationResult;
+export interface PackageMetadata {
+    name: string;
+    version: string;
+    type: "module";
+    license: string;
+    engines: {
+        node: string;
+    };
+    comity?: {
+        layer: string;
+        implements?: string;
+    };
+    exports: Record<string, unknown>;
+    typesVersions?: Record<string, unknown>;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ErrorObject[];
+}

package/dist/schemas/package-metadata.js

@@ -0,0 +1,147 @@
+import { createAjvInstance } from "../ajv-instance.js";
+import { MIN_NODE_VERSION, PACKAGE_NAME_PATTERN, RUNTIME_LAYERS, VALID_LAYERS, } from "../constants.js";
+/**
+ * Canonical schema for Comity package metadata.
+ *
+ * Covers both namespaces, with a name-scope ↔ layer boundary:
+ *   - `@comity/*` (runtime)     → `comity.layer` MUST be one of the six
+ *                                 runtime layers (ADR-026).
+ *   - `@comity-dev/*` (tooling) → `comity.layer` MUST be `dev-tooling`.
+ *
+ * The boundary is enforced by the `if/then/else` clause on `comity.layer`.
+ *
+ * @see ADR-026 — Architecture Validator Authoritative Classification
+ * @see layering-policy.md §2.1
+ * @see architecture-validation.md §8 (package naming, type, engines.node)
+ * @see public-api.md §3 (exports subpath rules)
+ *
+ * This schema is the authoritative machine-readable definition of what every
+ * Comity package manifest MUST contain. Repositories consume this schema via
+ * the shared `comity-validate` orchestrator; they do not redefine it.
+ */
+export const packageMetadataSchema = {
+    $id: "https://comityjs.dev/schemas/package-metadata.v1.json",
+    type: "object",
+    required: ["name", "version", "type", "license", "engines", "exports"],
+    additionalProperties: true,
+    properties: {
+        name: {
+            type: "string",
+            pattern: PACKAGE_NAME_PATTERN,
+            description: "Package name MUST follow the `@comity/<kebab-case-name>` or `@comity-dev/<kebab-case-name>` convention.",
+        },
+        version: {
+            type: "string",
+            pattern: "^[0-9]+\\.[0-9]+\\.[0-9]+",
+            description: "Semantic version of the package.",
+        },
+        type: {
+            const: "module",
+            description: "Package type MUST be `module` (ESM).",
+        },
+        license: {
+            type: "string",
+            minLength: 1,
+            description: "Package license MUST be declared.",
+        },
+        engines: {
+            type: "object",
+            required: ["node"],
+            properties: {
+                node: {
+                    type: "string",
+                    pattern: `>=${MIN_NODE_VERSION}`,
+                    description: `Node.js engine MUST be >= ${MIN_NODE_VERSION}.`,
+                },
+            },
+            additionalProperties: true,
+        },
+        comity: {
+            type: "object",
+            description: "Comity metadata — authoritative source of package classification.",
+            required: ["layer"],
+            properties: {
+                layer: {
+                    type: "string",
+                    enum: [...VALID_LAYERS],
+                    description: "Architectural layer. Runtime `@comity/*` packages MUST use one of the six runtime layers (primitives, kernel, composition, core, technology-adapter, integration-adapter). Development `@comity-dev/*` packages MUST use `dev-tooling`.",
+                },
+                implements: {
+                    // Per ADR-026, `implements` is a single Core Module name. The
+                    // legacy validator reports a violation when this is an array;
+                    // we keep the schema strict and surface the violation through
+                    // the metadata check.
+                    type: "string",
+                    pattern: PACKAGE_NAME_PATTERN,
+                    description: "Single Core Module that this Adapter implements (technology-adapter and integration-adapter).",
+                },
+            },
+            additionalProperties: false,
+        },
+        exports: {
+            type: "object",
+            description: "Declared public subpaths. Forbidden subpaths (utils, helpers, shared, internal, lazy) are validated by ESLint.",
+            additionalProperties: true,
+        },
+        typesVersions: {
+            type: "object",
+            description: "TypeScript typesVersions MUST be consistent with declared exports.",
+            additionalProperties: true,
+        },
+    },
+    // Name-scope ↔ layer boundary. The runtime six-layer model is
+    // preserved; `dev-tooling` is reserved for `@comity-dev/*`.
+    // Implemented at the manifest level so `name` and `comity.layer`
+    // can be evaluated as siblings.
+    allOf: [
+        {
+            if: {
+                properties: {
+                    name: { pattern: "^@comity/" },
+                },
+                required: ["name"],
+            },
+            then: {
+                properties: {
+                    comity: {
+                        properties: {
+                            layer: { enum: [...RUNTIME_LAYERS] },
+                        },
+                    },
+                },
+            },
+        },
+        {
+            if: {
+                properties: {
+                    name: { pattern: "^@comity-dev/" },
+                },
+                required: ["name"],
+            },
+            then: {
+                properties: {
+                    comity: {
+                        properties: {
+                            layer: { const: "dev-tooling" },
+                        },
+                    },
+                },
+            },
+        },
+    ],
+};
+/**
+ * Validates a parsed package.json against the canonical schema.
+ *
+ * @param manifest — parsed package.json object
+ * @param ajv — optional pre-built Ajv instance
+ * @returns validation result
+ */
+export function validatePackageMetadata(manifest, ajv = createAjvInstance()) {
+    const validate = ajv.compile(packageMetadataSchema);
+    const valid = validate(manifest);
+    return {
+        valid: Boolean(valid),
+        errors: valid ? [] : (validate.errors ?? []),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comity-dev/schemas",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Reusable JSON Schema definitions for Comity package metadata, ADR-008 register, and repository configuration. Development tooling.",
   "type": "module",
   "private": false,
@@ -40,7 +40,8 @@
     "typescript": "^5.9.3"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "vitest run"
+    "generate": "node scripts/generate-adr-008.mjs",
+    "build": "node scripts/generate-adr-008.mjs && node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
+    "test": "vitest run --passWithNoTests"
   }
 }