@qa-ai-stlc/schemas 0.0.0

package/README.md

@@ -0,0 +1,12 @@
+# @qa-ai-stlc/schemas
+
+Zod schemas for every QA-AI-STLC artifact under `.qa/`: config, scope, test case, run result,
+evidence, defect draft, RCA, selector registry, API surface, approval ledger and manifest. This is
+the versioned contract between the agent layer and the engine — every other package derives its
+types from `z.infer` here rather than declaring a parallel interface.
+
+Each schema also has a generated JSON Schema counterpart under `dist/json-schema/`, built with
+`npm run build`, for consumers outside TypeScript.
+
+Part of [QA-AI-STLC](https://github.com/Klim-101/QA-AI-STLC). See the repository root for
+license, contributing and security information.

package/dist/api-surface.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+export declare const HttpMethodSchema: z.ZodEnum<{
+    GET: "GET";
+    POST: "POST";
+    PUT: "PUT";
+    PATCH: "PATCH";
+    DELETE: "DELETE";
+    HEAD: "HEAD";
+    OPTIONS: "OPTIONS";
+}>;
+export type HttpMethod = z.infer<typeof HttpMethodSchema>;
+export declare const ApiEndpointSourceSchema: z.ZodEnum<{
+    openapi: "openapi";
+    discovered: "discovered";
+    synthesized: "synthesized";
+}>;
+export type ApiEndpointSource = z.infer<typeof ApiEndpointSourceSchema>;
+export declare const ApiEndpointSchema: z.ZodObject<{
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+        DELETE: "DELETE";
+        HEAD: "HEAD";
+        OPTIONS: "OPTIONS";
+    }>;
+    path: z.ZodString;
+    operationId: z.ZodOptional<z.ZodString>;
+    source: z.ZodEnum<{
+        openapi: "openapi";
+        discovered: "discovered";
+        synthesized: "synthesized";
+    }>;
+}, z.core.$strip>;
+export type ApiEndpoint = z.infer<typeof ApiEndpointSchema>;
+export declare const ApiSurfaceSchema: z.ZodObject<{
+    schemaVersion: z.ZodDefault<z.ZodLiteral<1>>;
+    generatedAt: z.ZodISODateTime;
+    contractSha256: z.ZodOptional<z.ZodString>;
+    endpoints: z.ZodArray<z.ZodObject<{
+        method: z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+            HEAD: "HEAD";
+            OPTIONS: "OPTIONS";
+        }>;
+        path: z.ZodString;
+        operationId: z.ZodOptional<z.ZodString>;
+        source: z.ZodEnum<{
+            openapi: "openapi";
+            discovered: "discovered";
+            synthesized: "synthesized";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ApiSurface = z.infer<typeof ApiSurfaceSchema>;
+//# sourceMappingURL=api-surface.d.ts.map

package/dist/api-surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-surface.d.ts","sourceRoot":"","sources":["../src/api-surface.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,gBAAgB;;;;;;;;EAAuE,CAAC;AACrG,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAI1D,eAAO,MAAM,uBAAuB;;;;EAAmD,CAAC;AACxF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;iBAK5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;iBAK3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/api-surface.js

@@ -0,0 +1,22 @@
+// Copyright The QA-AI-STLC Authors
+// SPDX-License-Identifier: Apache-2.0
+import { z } from 'zod';
+import { IsoDateTimeSchema, Sha256HexSchema } from './primitives.js';
+import { SCHEMA_VERSION, SchemaVersionSchema } from './version.js';
+export const HttpMethodSchema = z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']);
+// Matches the three contract sources `api.source` allows in config.yaml (development plan
+// section 3.3): a supplied or discovered document, or an operator-approved synthesized draft.
+export const ApiEndpointSourceSchema = z.enum(['openapi', 'discovered', 'synthesized']);
+export const ApiEndpointSchema = z.object({
+    method: HttpMethodSchema,
+    path: z.string().min(1),
+    operationId: z.string().optional(),
+    source: ApiEndpointSourceSchema,
+});
+export const ApiSurfaceSchema = z.object({
+    schemaVersion: SchemaVersionSchema.default(SCHEMA_VERSION),
+    generatedAt: IsoDateTimeSchema,
+    contractSha256: Sha256HexSchema.optional(),
+    endpoints: z.array(ApiEndpointSchema),
+});
+//# sourceMappingURL=api-surface.js.map

package/dist/api-surface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-surface.js","sourceRoot":"","sources":["../src/api-surface.ts"],"names":[],"mappings":"AAAA,mCAAmC;AACnC,sCAAsC;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEnE,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;AAGrG,0FAA0F;AAC1F,8FAA8F;AAC9F,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,YAAY,EAAE,aAAa,CAAC,CAAC,CAAC;AAGxF,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,MAAM,EAAE,gBAAgB;IACxB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,MAAM,EAAE,uBAAuB;CAChC,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,aAAa,EAAE,mBAAmB,CAAC,OAAO,CAAC,cAAc,CAAC;IAC1D,WAAW,EAAE,iBAAiB;IAC9B,cAAc,EAAE,eAAe,CAAC,QAAQ,EAAE;IAC1C,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC;CACtC,CAAC,CAAC"}

package/dist/approval-ledger.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export declare const ApprovalSchema: z.ZodObject<{
+    gate: z.ZodString;
+    artifactPath: z.ZodString;
+    artifactSha256: z.ZodString;
+    approvedBy: z.ZodString;
+    approvedAt: z.ZodISODateTime;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Approval = z.infer<typeof ApprovalSchema>;
+export declare const ApprovalLedgerSchema: z.ZodObject<{
+    schemaVersion: z.ZodDefault<z.ZodLiteral<1>>;
+    approvals: z.ZodArray<z.ZodObject<{
+        gate: z.ZodString;
+        artifactPath: z.ZodString;
+        artifactSha256: z.ZodString;
+        approvedBy: z.ZodString;
+        approvedAt: z.ZodISODateTime;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ApprovalLedger = z.infer<typeof ApprovalLedgerSchema>;
+//# sourceMappingURL=approval-ledger.d.ts.map

package/dist/approval-ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval-ledger.d.ts","sourceRoot":"","sources":["../src/approval-ledger.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,cAAc;;;;;;;iBAOzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,eAAO,MAAM,oBAAoB;;;;;;;;;;iBAG/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/approval-ledger.js

@@ -0,0 +1,22 @@
+// Copyright The QA-AI-STLC Authors
+// SPDX-License-Identifier: Apache-2.0
+import { z } from 'zod';
+import { IsoDateTimeSchema, RelativePathSchema, Sha256HexSchema } from './primitives.js';
+import { SCHEMA_VERSION, SchemaVersionSchema } from './version.js';
+// One entry per hash-bound gate (ADR-003): `artifactSha256` is the hash of the exact artifact
+// content approved. `qa validate` recomputes the current artifact's hash and compares it to this
+// value; a mismatch means the gate is no longer satisfied regardless of any status field on the
+// artifact itself.
+export const ApprovalSchema = z.object({
+    gate: z.string().min(1),
+    artifactPath: RelativePathSchema,
+    artifactSha256: Sha256HexSchema,
+    approvedBy: z.string().min(1),
+    approvedAt: IsoDateTimeSchema,
+    note: z.string().optional(),
+});
+export const ApprovalLedgerSchema = z.object({
+    schemaVersion: SchemaVersionSchema.default(SCHEMA_VERSION),
+    approvals: z.array(ApprovalSchema),
+});
+//# sourceMappingURL=approval-ledger.js.map

package/dist/approval-ledger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval-ledger.js","sourceRoot":"","sources":["../src/approval-ledger.ts"],"names":[],"mappings":"AAAA,mCAAmC;AACnC,sCAAsC;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACzF,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEnE,8FAA8F;AAC9F,iGAAiG;AACjG,gGAAgG;AAChG,mBAAmB;AACnB,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC;IACrC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,YAAY,EAAE,kBAAkB;IAChC,cAAc,EAAE,eAAe;IAC/B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7B,UAAU,EAAE,iBAAiB;IAC7B,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC5B,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,aAAa,EAAE,mBAAmB,CAAC,OAAO,CAAC,cAAc,CAAC;IAC1D,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC;CACnC,CAAC,CAAC"}

package/dist/artifacts.d.ts

@@ -0,0 +1,285 @@
+export declare const artifactSchemas: {
+    readonly config: import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodDefault<import("zod").ZodLiteral<1>>;
+        testing: import("zod").ZodObject<{
+            e2e: import("zod").ZodEnum<{
+                "in-scope": "in-scope";
+                "out-of-scope": "out-of-scope";
+                undecided: "undecided";
+            }>;
+            api: import("zod").ZodEnum<{
+                "in-scope": "in-scope";
+                "out-of-scope": "out-of-scope";
+                undecided: "undecided";
+            }>;
+            a11y: import("zod").ZodEnum<{
+                "in-scope": "in-scope";
+                "out-of-scope": "out-of-scope";
+                undecided: "undecided";
+            }>;
+            security: import("zod").ZodEnum<{
+                "in-scope": "in-scope";
+                "out-of-scope": "out-of-scope";
+                undecided: "undecided";
+            }>;
+        }, import("zod/v4/core").$strip>;
+        source: import("zod").ZodOptional<import("zod").ZodObject<{
+            path: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+        api: import("zod").ZodOptional<import("zod").ZodObject<{
+            contract: import("zod").ZodLiteral<"openapi">;
+            source: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<"discover">, import("zod").ZodLiteral<"synthesize">]>;
+        }, import("zod/v4/core").$strip>>;
+        environments: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            baseUrl: import("zod").ZodString;
+            allowlist: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        identities: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            auth: import("zod").ZodEnum<{
+                "cdp-attach": "cdp-attach";
+                "storage-state": "storage-state";
+            }>;
+            secret: import("zod").ZodString;
+            loginUrl: import("zod").ZodOptional<import("zod").ZodString>;
+            username: import("zod").ZodOptional<import("zod").ZodString>;
+            selectors: import("zod").ZodOptional<import("zod").ZodObject<{
+                username: import("zod").ZodOptional<import("zod").ZodString>;
+                password: import("zod").ZodOptional<import("zod").ZodString>;
+                submit: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>>;
+        data: import("zod").ZodObject<{
+            strategy: import("zod").ZodEnum<{
+                disposable: "disposable";
+                "reset-endpoint": "reset-endpoint";
+                manual: "manual";
+            }>;
+            ownerMarker: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        selectors: import("zod").ZodObject<{
+            policy: import("zod").ZodEnum<{
+                "playwright-default": "playwright-default";
+                "testid-first": "testid-first";
+                "strict-no-css": "strict-no-css";
+            }>;
+            testIdAttribute: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        agents: import("zod").ZodObject<{
+            parallelism: import("zod").ZodNumber;
+            spokeTimeoutSeconds: import("zod").ZodNumber;
+            retries: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>;
+    readonly scope: import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodDefault<import("zod").ZodLiteral<1>>;
+        generatedAt: import("zod").ZodISODateTime;
+        requirements: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            title: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            source: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"file">;
+                path: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"text">;
+                label: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>]>;
+            inScope: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+    readonly 'test-case': import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodDefault<import("zod").ZodLiteral<1>>;
+        id: import("zod").ZodString;
+        requirementIds: import("zod").ZodArray<import("zod").ZodString>;
+        testType: import("zod").ZodEnum<{
+            e2e: "e2e";
+            api: "api";
+            a11y: "a11y";
+        }>;
+        title: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        steps: import("zod").ZodArray<import("zod").ZodObject<{
+            description: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+        expectedResult: import("zod").ZodString;
+        status: import("zod").ZodEnum<{
+            draft: "draft";
+            rejected: "rejected";
+            approved: "approved";
+        }>;
+        createdAt: import("zod").ZodISODateTime;
+    }, import("zod/v4/core").$strip>;
+    readonly 'run-result': import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodDefault<import("zod").ZodLiteral<1>>;
+        id: import("zod").ZodString;
+        runId: import("zod").ZodString;
+        testCaseId: import("zod").ZodString;
+        testType: import("zod").ZodEnum<{
+            e2e: "e2e";
+            api: "api";
+            a11y: "a11y";
+        }>;
+        status: import("zod").ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+            blocked: "blocked";
+            skipped: "skipped";
+            uncertain: "uncertain";
+            partial: "partial";
+        }>;
+        startedAt: import("zod").ZodISODateTime;
+        finishedAt: import("zod").ZodISODateTime;
+        evidenceIds: import("zod").ZodArray<import("zod").ZodString>;
+        failure: import("zod").ZodOptional<import("zod").ZodObject<{
+            message: import("zod").ZodString;
+            stack: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+    readonly evidence: import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodDefault<import("zod").ZodLiteral<1>>;
+        id: import("zod").ZodString;
+        runId: import("zod").ZodString;
+        stepId: import("zod").ZodOptional<import("zod").ZodString>;
+        kind: import("zod").ZodEnum<{
+            screenshot: "screenshot";
+            trace: "trace";
+            "network-har": "network-har";
+            "console-log": "console-log";
+            video: "video";
+            other: "other";
+        }>;
+        path: import("zod").ZodString;
+        sha256: import("zod").ZodString;
+        createdAt: import("zod").ZodISODateTime;
+        redacted: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>;
+    readonly 'defect-draft': import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodDefault<import("zod").ZodLiteral<1>>;
+        id: import("zod").ZodString;
+        title: import("zod").ZodString;
+        severityProposal: import("zod").ZodEnum<{
+            blocker: "blocker";
+            critical: "critical";
+            major: "major";
+            minor: "minor";
+            trivial: "trivial";
+        }>;
+        category: import("zod").ZodEnum<{
+            api: "api";
+            security: "security";
+            functional: "functional";
+            ui: "ui";
+            accessibility: "accessibility";
+            performance: "performance";
+        }>;
+        steps: import("zod").ZodArray<import("zod").ZodString>;
+        expectedResult: import("zod").ZodString;
+        actualResult: import("zod").ZodString;
+        environment: import("zod").ZodString;
+        requirementIds: import("zod").ZodArray<import("zod").ZodString>;
+        evidencePaths: import("zod").ZodArray<import("zod").ZodString>;
+        status: import("zod").ZodEnum<{
+            draft: "draft";
+            accepted: "accepted";
+            rejected: "rejected";
+        }>;
+        createdAt: import("zod").ZodISODateTime;
+        securityRiskArea: import("zod").ZodOptional<import("zod").ZodString>;
+        securityConfidence: import("zod").ZodOptional<import("zod").ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
+        securitySuggestedRemediation: import("zod").ZodOptional<import("zod").ZodString>;
+        securityRegressionCheck: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>;
+    readonly rca: import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodDefault<import("zod").ZodLiteral<1>>;
+        defectId: import("zod").ZodString;
+        facts: import("zod").ZodArray<import("zod").ZodString>;
+        hypotheses: import("zod").ZodArray<import("zod").ZodObject<{
+            description: import("zod").ZodString;
+            confidence: import("zod").ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>;
+            evidenceNeeded: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        remediation: import("zod").ZodArray<import("zod").ZodString>;
+        regressionRecommendation: import("zod").ZodOptional<import("zod").ZodString>;
+        status: import("zod").ZodEnum<{
+            draft: "draft";
+            rejected: "rejected";
+            approved: "approved";
+        }>;
+        createdAt: import("zod").ZodISODateTime;
+    }, import("zod/v4/core").$strip>;
+    readonly 'selector-registry': import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodDefault<import("zod").ZodLiteral<1>>;
+        generatedAt: import("zod").ZodISODateTime;
+        elements: import("zod").ZodArray<import("zod").ZodObject<{
+            elementId: import("zod").ZodString;
+            kind: import("zod").ZodString;
+            library: import("zod").ZodOptional<import("zod").ZodString>;
+            locatorCandidates: import("zod").ZodArray<import("zod").ZodObject<{
+                strategy: import("zod").ZodString;
+                value: import("zod").ZodString;
+                fragile: import("zod").ZodBoolean;
+            }, import("zod/v4/core").$strip>>;
+            stabilityScore: import("zod").ZodNumber;
+            lastVerifiedAt: import("zod").ZodISODateTime;
+            pii: import("zod").ZodBoolean;
+            dynamicText: import("zod").ZodBoolean;
+            source: import("zod").ZodEnum<{
+                manual: "manual";
+                crawl: "crawl";
+                static: "static";
+            }>;
+            deprecatedAt: import("zod").ZodOptional<import("zod").ZodISODateTime>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+    readonly 'api-surface': import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodDefault<import("zod").ZodLiteral<1>>;
+        generatedAt: import("zod").ZodISODateTime;
+        contractSha256: import("zod").ZodOptional<import("zod").ZodString>;
+        endpoints: import("zod").ZodArray<import("zod").ZodObject<{
+            method: import("zod").ZodEnum<{
+                GET: "GET";
+                POST: "POST";
+                PUT: "PUT";
+                PATCH: "PATCH";
+                DELETE: "DELETE";
+                HEAD: "HEAD";
+                OPTIONS: "OPTIONS";
+            }>;
+            path: import("zod").ZodString;
+            operationId: import("zod").ZodOptional<import("zod").ZodString>;
+            source: import("zod").ZodEnum<{
+                openapi: "openapi";
+                discovered: "discovered";
+                synthesized: "synthesized";
+            }>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+    readonly 'approval-ledger': import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodDefault<import("zod").ZodLiteral<1>>;
+        approvals: import("zod").ZodArray<import("zod").ZodObject<{
+            gate: import("zod").ZodString;
+            artifactPath: import("zod").ZodString;
+            artifactSha256: import("zod").ZodString;
+            approvedBy: import("zod").ZodString;
+            approvedAt: import("zod").ZodISODateTime;
+            note: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+    readonly manifest: import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodDefault<import("zod").ZodLiteral<1>>;
+        artifacts: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            sha256: import("zod").ZodString;
+            registeredAt: import("zod").ZodISODateTime;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+};
+export type ArtifactKind = keyof typeof artifactSchemas;
+//# sourceMappingURL=artifacts.d.ts.map

package/dist/artifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.d.ts","sourceRoot":"","sources":["../src/artifacts.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYlB,CAAC;AACX,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,eAAe,CAAC"}

package/dist/artifacts.js

@@ -0,0 +1,30 @@
+// Copyright The QA-AI-STLC Authors
+// SPDX-License-Identifier: Apache-2.0
+import { ApiSurfaceSchema } from './api-surface.js';
+import { ApprovalLedgerSchema } from './approval-ledger.js';
+import { ConfigSchema } from './config.js';
+import { DefectDraftSchema } from './defect.js';
+import { EvidenceSchema } from './evidence.js';
+import { ManifestSchema } from './manifest.js';
+import { RcaSchema } from './rca.js';
+import { RunResultSchema } from './run-result.js';
+import { ScopeSchema } from './scope.js';
+import { SelectorRegistrySchema } from './selector-registry.js';
+import { TestCaseSchema } from './test-case.js';
+// One entry per artifact kind under `.qa/` (development plan section 3.2). This is the single
+// source `scripts/generate-json-schema.mjs` walks to emit `dist/json-schema/<name>.json`; adding
+// a new artifact kind means adding it here, not teaching the generator a new naming heuristic.
+export const artifactSchemas = {
+    config: ConfigSchema,
+    scope: ScopeSchema,
+    'test-case': TestCaseSchema,
+    'run-result': RunResultSchema,
+    evidence: EvidenceSchema,
+    'defect-draft': DefectDraftSchema,
+    rca: RcaSchema,
+    'selector-registry': SelectorRegistrySchema,
+    'api-surface': ApiSurfaceSchema,
+    'approval-ledger': ApprovalLedgerSchema,
+    manifest: ManifestSchema,
+};
+//# sourceMappingURL=artifacts.js.map

package/dist/artifacts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.js","sourceRoot":"","sources":["../src/artifacts.ts"],"names":[],"mappings":"AAAA,mCAAmC;AACnC,sCAAsC;AAEtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEhD,8FAA8F;AAC9F,iGAAiG;AACjG,+FAA+F;AAC/F,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,MAAM,EAAE,YAAY;IACpB,KAAK,EAAE,WAAW;IAClB,WAAW,EAAE,cAAc;IAC3B,YAAY,EAAE,eAAe;IAC7B,QAAQ,EAAE,cAAc;IACxB,cAAc,EAAE,iBAAiB;IACjC,GAAG,EAAE,SAAS;IACd,mBAAmB,EAAE,sBAAsB;IAC3C,aAAa,EAAE,gBAAgB;IAC/B,iBAAiB,EAAE,oBAAoB;IACvC,QAAQ,EAAE,cAAc;CAChB,CAAC"}