@neuraloom/contracts 0.0.0-stage → 0.1.22

package/dist/schemas/assurance/domain-assurance-evidence-pack.schema.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainAssuranceEvidencePackSchema = void 0;
+/**
+ * Domain Assurance Evidence Pack — the single artifact a management reviewer inspects
+ * before accepting a G0-D+ product as enterprise-ready. Bundles every gate's evidence
+ * so no claim can be accepted without a linked, executable proof object.
+ */
+const zod_1 = require("zod");
+const browser_outcome_proof_schema_1 = require("./browser-outcome-proof.schema");
+const documentation_evidence_schema_1 = require("./documentation-evidence.schema");
+const domain_assurance_verdict_schema_1 = require("./domain-assurance-verdict.schema");
+const domain_truth_brief_schema_1 = require("./domain-truth-brief.schema");
+const enterprise_targeting_schema_1 = require("./enterprise-targeting.schema");
+const release_verdict_schema_1 = require("./release-verdict.schema");
+exports.DomainAssuranceEvidencePackSchema = zod_1.z
+    .object({
+    productId: zod_1.z.string().min(1),
+    workflowRunId: zod_1.z.string().min(1),
+    enterpriseTargeting: enterprise_targeting_schema_1.EnterpriseTargetingSchema,
+    domainTruthBrief: domain_truth_brief_schema_1.DomainTruthBriefSchema,
+    domainAssuranceVerdict: domain_assurance_verdict_schema_1.DomainAssuranceVerdictSchema,
+    browserOutcomeProof: browser_outcome_proof_schema_1.BrowserOutcomeProofResultSchema.optional(),
+    documentationEvidenceMap: documentation_evidence_schema_1.DocumentationEvidenceMapSchema,
+    releaseVerdict: release_verdict_schema_1.ReleaseVerdictSchema,
+    generatedAt: zod_1.z.string().datetime(),
+})
+    .strict();

package/dist/schemas/assurance/domain-assurance-verdict.schema.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Domain Assurance Verdict — aggregate of Gates 0-10 for one product/workflow run.
+ * Replaces keyword-based `domainChecks` (product-route-probe marker counting) for G0-D+ products.
+ */
+import { z } from 'zod';
+export declare const DomainAssuranceVerdictSchema: z.ZodObject<{
+    productId: z.ZodString;
+    workflowRunId: z.ZodString;
+    riskClass: z.ZodEnum<["G0-A", "G0-B", "G0-C", "G0-D", "G0-E"]>;
+    gates: z.ZodRecord<z.ZodEnum<["riskClassification", "domainTruthBrief", "canonicalKernel", "referenceCases", "physicalQuantitySchemas", "fixtureIntegrity", "livePathVerification", "browserOutcomeProof", "authTenantAudit", "documentationEvidence", "releaseVerdict"]>, z.ZodEnum<["pass", "warn", "fail"]>>;
+    overallVerdict: z.ZodEnum<["pass", "warn", "fail"]>;
+    releaseBlockers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    knownLimitations: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    evidenceLinks: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    manualApprovalsRequired: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    lastVerifiedAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    gates: Partial<Record<"referenceCases" | "riskClassification" | "domainTruthBrief" | "canonicalKernel" | "physicalQuantitySchemas" | "fixtureIntegrity" | "livePathVerification" | "browserOutcomeProof" | "authTenantAudit" | "documentationEvidence" | "releaseVerdict", "warn" | "fail" | "pass">>;
+    productId: string;
+    riskClass: "G0-A" | "G0-B" | "G0-C" | "G0-D" | "G0-E";
+    workflowRunId: string;
+    overallVerdict: "warn" | "fail" | "pass";
+    releaseBlockers: string[];
+    knownLimitations: string[];
+    evidenceLinks: string[];
+    manualApprovalsRequired: string[];
+    lastVerifiedAt: string;
+}, {
+    gates: Partial<Record<"referenceCases" | "riskClassification" | "domainTruthBrief" | "canonicalKernel" | "physicalQuantitySchemas" | "fixtureIntegrity" | "livePathVerification" | "browserOutcomeProof" | "authTenantAudit" | "documentationEvidence" | "releaseVerdict", "warn" | "fail" | "pass">>;
+    productId: string;
+    riskClass: "G0-A" | "G0-B" | "G0-C" | "G0-D" | "G0-E";
+    workflowRunId: string;
+    overallVerdict: "warn" | "fail" | "pass";
+    lastVerifiedAt: string;
+    releaseBlockers?: string[] | undefined;
+    knownLimitations?: string[] | undefined;
+    evidenceLinks?: string[] | undefined;
+    manualApprovalsRequired?: string[] | undefined;
+}>;
+export type DomainAssuranceVerdict = z.infer<typeof DomainAssuranceVerdictSchema>;

package/dist/schemas/assurance/domain-assurance-verdict.schema.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Domain Assurance Verdict — aggregate of Gates 0-10 for one product/workflow run.
+ * Replaces keyword-based `domainChecks` (product-route-probe marker counting) for G0-D+ products.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainAssuranceVerdictSchema = void 0;
+const zod_1 = require("zod");
+const gate_result_schema_1 = require("./gate-result.schema");
+const risk_class_schema_1 = require("./risk-class.schema");
+exports.DomainAssuranceVerdictSchema = zod_1.z
+    .object({
+    productId: zod_1.z.string().min(1),
+    workflowRunId: zod_1.z.string().min(1),
+    riskClass: risk_class_schema_1.ProjectRiskClassSchema,
+    gates: zod_1.z.record(gate_result_schema_1.DomainAssuranceGateIdSchema, gate_result_schema_1.DomainAssuranceGateStatusSchema),
+    overallVerdict: gate_result_schema_1.DomainAssuranceGateStatusSchema,
+    releaseBlockers: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+    knownLimitations: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+    evidenceLinks: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+    manualApprovalsRequired: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+    lastVerifiedAt: zod_1.z.string().datetime(),
+})
+    .strict();

package/dist/schemas/assurance/domain-truth-brief.schema.d.ts

@@ -0,0 +1,270 @@
+/**
+ * Domain Truth Brief — mandatory pre-Implement artifact for G0-D/G0-E products (Gate 1).
+ * Identifies the irreducible domain kernel before any UI/route work begins.
+ */
+import { z } from 'zod';
+export declare const DomainQuantityTypeSchema: z.ZodEnum<["physical", "derived", "observed", "system_generated_result", "approval_state", "audit_metadata", "plain_data"]>;
+export type DomainQuantityType = z.infer<typeof DomainQuantityTypeSchema>;
+export declare const DomainQuantitySchema: z.ZodObject<{
+    name: z.ZodString;
+    unit: z.ZodOptional<z.ZodString>;
+    quantityType: z.ZodEnum<["physical", "derived", "observed", "system_generated_result", "approval_state", "audit_metadata", "plain_data"]>;
+    validRange: z.ZodOptional<z.ZodObject<{
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        min?: number | undefined;
+        max?: number | undefined;
+    }, {
+        min?: number | undefined;
+        max?: number | undefined;
+    }>>;
+    impossibleValues: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    quantityType: "physical" | "derived" | "observed" | "system_generated_result" | "approval_state" | "audit_metadata" | "plain_data";
+    impossibleValues: string[];
+    unit?: string | undefined;
+    validRange?: {
+        min?: number | undefined;
+        max?: number | undefined;
+    } | undefined;
+}, {
+    name: string;
+    quantityType: "physical" | "derived" | "observed" | "system_generated_result" | "approval_state" | "audit_metadata" | "plain_data";
+    unit?: string | undefined;
+    validRange?: {
+        min?: number | undefined;
+        max?: number | undefined;
+    } | undefined;
+    impossibleValues?: string[] | undefined;
+}>;
+export type DomainQuantity = z.infer<typeof DomainQuantitySchema>;
+export declare const DomainReferenceCaseSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    kind: z.ZodEnum<["normal", "boundary", "impossible"]>;
+    inputs: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    expectedOutput: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    expectedRejection: z.ZodOptional<z.ZodBoolean>;
+    independentlyDerivedFrom: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    description: string;
+    kind: "normal" | "boundary" | "impossible";
+    inputs: Record<string, unknown>;
+    independentlyDerivedFrom: string;
+    expectedOutput?: Record<string, unknown> | undefined;
+    expectedRejection?: boolean | undefined;
+}, {
+    id: string;
+    description: string;
+    kind: "normal" | "boundary" | "impossible";
+    inputs: Record<string, unknown>;
+    independentlyDerivedFrom: string;
+    expectedOutput?: Record<string, unknown> | undefined;
+    expectedRejection?: boolean | undefined;
+}>;
+export type DomainReferenceCase = z.infer<typeof DomainReferenceCaseSchema>;
+export declare const DomainTruthBriefSchema: z.ZodEffects<z.ZodObject<{
+    productId: z.ZodString;
+    coreDomainProblem: z.ZodString;
+    authoritativeFormulasOrRules: z.ZodArray<z.ZodString, "many">;
+    domainInvariants: z.ZodArray<z.ZodString, "many">;
+    quantities: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        unit: z.ZodOptional<z.ZodString>;
+        quantityType: z.ZodEnum<["physical", "derived", "observed", "system_generated_result", "approval_state", "audit_metadata", "plain_data"]>;
+        validRange: z.ZodOptional<z.ZodObject<{
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            min?: number | undefined;
+            max?: number | undefined;
+        }, {
+            min?: number | undefined;
+            max?: number | undefined;
+        }>>;
+        impossibleValues: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        quantityType: "physical" | "derived" | "observed" | "system_generated_result" | "approval_state" | "audit_metadata" | "plain_data";
+        impossibleValues: string[];
+        unit?: string | undefined;
+        validRange?: {
+            min?: number | undefined;
+            max?: number | undefined;
+        } | undefined;
+    }, {
+        name: string;
+        quantityType: "physical" | "derived" | "observed" | "system_generated_result" | "approval_state" | "audit_metadata" | "plain_data";
+        unit?: string | undefined;
+        validRange?: {
+            min?: number | undefined;
+            max?: number | undefined;
+        } | undefined;
+        impossibleValues?: string[] | undefined;
+    }>, "many">;
+    coordinateFramesOrJurisdictions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    sourceData: z.ZodArray<z.ZodString, "many">;
+    derivedData: z.ZodArray<z.ZodString, "many">;
+    referenceCases: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        kind: z.ZodEnum<["normal", "boundary", "impossible"]>;
+        inputs: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        expectedOutput: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        expectedRejection: z.ZodOptional<z.ZodBoolean>;
+        independentlyDerivedFrom: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        description: string;
+        kind: "normal" | "boundary" | "impossible";
+        inputs: Record<string, unknown>;
+        independentlyDerivedFrom: string;
+        expectedOutput?: Record<string, unknown> | undefined;
+        expectedRejection?: boolean | undefined;
+    }, {
+        id: string;
+        description: string;
+        kind: "normal" | "boundary" | "impossible";
+        inputs: Record<string, unknown>;
+        independentlyDerivedFrom: string;
+        expectedOutput?: Record<string, unknown> | undefined;
+        expectedRejection?: boolean | undefined;
+    }>, "many">;
+    failureModes: z.ZodArray<z.ZodString, "many">;
+    standardsOrAuthoritativeReferences: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    humanReviewRequired: z.ZodBoolean;
+    approvedBy: z.ZodOptional<z.ZodString>;
+    approvedAt: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    productId: string;
+    coreDomainProblem: string;
+    authoritativeFormulasOrRules: string[];
+    domainInvariants: string[];
+    quantities: {
+        name: string;
+        quantityType: "physical" | "derived" | "observed" | "system_generated_result" | "approval_state" | "audit_metadata" | "plain_data";
+        impossibleValues: string[];
+        unit?: string | undefined;
+        validRange?: {
+            min?: number | undefined;
+            max?: number | undefined;
+        } | undefined;
+    }[];
+    coordinateFramesOrJurisdictions: string[];
+    sourceData: string[];
+    derivedData: string[];
+    referenceCases: {
+        id: string;
+        description: string;
+        kind: "normal" | "boundary" | "impossible";
+        inputs: Record<string, unknown>;
+        independentlyDerivedFrom: string;
+        expectedOutput?: Record<string, unknown> | undefined;
+        expectedRejection?: boolean | undefined;
+    }[];
+    failureModes: string[];
+    standardsOrAuthoritativeReferences: string[];
+    humanReviewRequired: boolean;
+    approvedBy?: string | undefined;
+    approvedAt?: string | undefined;
+}, {
+    productId: string;
+    coreDomainProblem: string;
+    authoritativeFormulasOrRules: string[];
+    domainInvariants: string[];
+    quantities: {
+        name: string;
+        quantityType: "physical" | "derived" | "observed" | "system_generated_result" | "approval_state" | "audit_metadata" | "plain_data";
+        unit?: string | undefined;
+        validRange?: {
+            min?: number | undefined;
+            max?: number | undefined;
+        } | undefined;
+        impossibleValues?: string[] | undefined;
+    }[];
+    sourceData: string[];
+    derivedData: string[];
+    referenceCases: {
+        id: string;
+        description: string;
+        kind: "normal" | "boundary" | "impossible";
+        inputs: Record<string, unknown>;
+        independentlyDerivedFrom: string;
+        expectedOutput?: Record<string, unknown> | undefined;
+        expectedRejection?: boolean | undefined;
+    }[];
+    failureModes: string[];
+    humanReviewRequired: boolean;
+    coordinateFramesOrJurisdictions?: string[] | undefined;
+    standardsOrAuthoritativeReferences?: string[] | undefined;
+    approvedBy?: string | undefined;
+    approvedAt?: string | undefined;
+}>, {
+    productId: string;
+    coreDomainProblem: string;
+    authoritativeFormulasOrRules: string[];
+    domainInvariants: string[];
+    quantities: {
+        name: string;
+        quantityType: "physical" | "derived" | "observed" | "system_generated_result" | "approval_state" | "audit_metadata" | "plain_data";
+        impossibleValues: string[];
+        unit?: string | undefined;
+        validRange?: {
+            min?: number | undefined;
+            max?: number | undefined;
+        } | undefined;
+    }[];
+    coordinateFramesOrJurisdictions: string[];
+    sourceData: string[];
+    derivedData: string[];
+    referenceCases: {
+        id: string;
+        description: string;
+        kind: "normal" | "boundary" | "impossible";
+        inputs: Record<string, unknown>;
+        independentlyDerivedFrom: string;
+        expectedOutput?: Record<string, unknown> | undefined;
+        expectedRejection?: boolean | undefined;
+    }[];
+    failureModes: string[];
+    standardsOrAuthoritativeReferences: string[];
+    humanReviewRequired: boolean;
+    approvedBy?: string | undefined;
+    approvedAt?: string | undefined;
+}, {
+    productId: string;
+    coreDomainProblem: string;
+    authoritativeFormulasOrRules: string[];
+    domainInvariants: string[];
+    quantities: {
+        name: string;
+        quantityType: "physical" | "derived" | "observed" | "system_generated_result" | "approval_state" | "audit_metadata" | "plain_data";
+        unit?: string | undefined;
+        validRange?: {
+            min?: number | undefined;
+            max?: number | undefined;
+        } | undefined;
+        impossibleValues?: string[] | undefined;
+    }[];
+    sourceData: string[];
+    derivedData: string[];
+    referenceCases: {
+        id: string;
+        description: string;
+        kind: "normal" | "boundary" | "impossible";
+        inputs: Record<string, unknown>;
+        independentlyDerivedFrom: string;
+        expectedOutput?: Record<string, unknown> | undefined;
+        expectedRejection?: boolean | undefined;
+    }[];
+    failureModes: string[];
+    humanReviewRequired: boolean;
+    coordinateFramesOrJurisdictions?: string[] | undefined;
+    standardsOrAuthoritativeReferences?: string[] | undefined;
+    approvedBy?: string | undefined;
+    approvedAt?: string | undefined;
+}>;
+export type DomainTruthBrief = z.infer<typeof DomainTruthBriefSchema>;

package/dist/schemas/assurance/domain-truth-brief.schema.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Domain Truth Brief — mandatory pre-Implement artifact for G0-D/G0-E products (Gate 1).
+ * Identifies the irreducible domain kernel before any UI/route work begins.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainTruthBriefSchema = exports.DomainReferenceCaseSchema = exports.DomainQuantitySchema = exports.DomainQuantityTypeSchema = void 0;
+const zod_1 = require("zod");
+exports.DomainQuantityTypeSchema = zod_1.z.enum([
+    'physical',
+    'derived',
+    'observed',
+    'system_generated_result',
+    'approval_state',
+    'audit_metadata',
+    'plain_data',
+]);
+exports.DomainQuantitySchema = zod_1.z
+    .object({
+    name: zod_1.z.string().min(1),
+    unit: zod_1.z.string().min(1).optional(),
+    quantityType: exports.DomainQuantityTypeSchema,
+    validRange: zod_1.z
+        .object({
+        min: zod_1.z.number().optional(),
+        max: zod_1.z.number().optional(),
+    })
+        .strict()
+        .optional(),
+    impossibleValues: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+})
+    .strict();
+exports.DomainReferenceCaseSchema = zod_1.z
+    .object({
+    id: zod_1.z.string().min(1),
+    description: zod_1.z.string().min(1),
+    kind: zod_1.z.enum(['normal', 'boundary', 'impossible']),
+    inputs: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
+    expectedOutput: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+    expectedRejection: zod_1.z.boolean().optional(),
+    independentlyDerivedFrom: zod_1.z.string().min(1),
+})
+    .strict();
+exports.DomainTruthBriefSchema = zod_1.z
+    .object({
+    productId: zod_1.z.string().min(1),
+    coreDomainProblem: zod_1.z.string().min(1),
+    authoritativeFormulasOrRules: zod_1.z.array(zod_1.z.string().min(1)).min(1),
+    domainInvariants: zod_1.z.array(zod_1.z.string().min(1)),
+    quantities: zod_1.z.array(exports.DomainQuantitySchema).min(1),
+    coordinateFramesOrJurisdictions: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+    sourceData: zod_1.z.array(zod_1.z.string().min(1)),
+    derivedData: zod_1.z.array(zod_1.z.string().min(1)),
+    referenceCases: zod_1.z.array(exports.DomainReferenceCaseSchema).min(1),
+    failureModes: zod_1.z.array(zod_1.z.string().min(1)),
+    standardsOrAuthoritativeReferences: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+    humanReviewRequired: zod_1.z.boolean(),
+    approvedBy: zod_1.z.string().min(1).optional(),
+    approvedAt: zod_1.z.string().datetime().optional(),
+})
+    .strict()
+    .superRefine((brief, ctx) => {
+    const kinds = new Set(brief.referenceCases.map((c) => c.kind));
+    for (const required of ['normal', 'boundary', 'impossible']) {
+        if (!kinds.has(required)) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `referenceCases must include at least one "${required}" case`,
+                path: ['referenceCases'],
+            });
+        }
+    }
+});

package/dist/schemas/assurance/enterprise-targeting.schema.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Enterprise targeting artifact — required before Implement for strict-assurance risk classes.
+ * Shapes browser outcome proof and release verdict, not marketing copy.
+ */
+import { z } from 'zod';
+export declare const EnterpriseTargetingSchema: z.ZodObject<{
+    productId: z.ZodString;
+    buyer: z.ZodString;
+    operator: z.ZodString;
+    approver: z.ZodString;
+    auditor: z.ZodString;
+    riskHolder: z.ZodString;
+    jobToBeDone: z.ZodString;
+    businessOutcome: z.ZodString;
+    failureConsequence: z.ZodString;
+    trustEvidenceRequired: z.ZodArray<z.ZodString, "many">;
+    releaseAcceptanceCriteria: z.ZodArray<z.ZodString, "many">;
+    createdAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    operator: string;
+    createdAt: string;
+    productId: string;
+    buyer: string;
+    approver: string;
+    auditor: string;
+    riskHolder: string;
+    jobToBeDone: string;
+    businessOutcome: string;
+    failureConsequence: string;
+    trustEvidenceRequired: string[];
+    releaseAcceptanceCriteria: string[];
+}, {
+    operator: string;
+    createdAt: string;
+    productId: string;
+    buyer: string;
+    approver: string;
+    auditor: string;
+    riskHolder: string;
+    jobToBeDone: string;
+    businessOutcome: string;
+    failureConsequence: string;
+    trustEvidenceRequired: string[];
+    releaseAcceptanceCriteria: string[];
+}>;
+export type EnterpriseTargeting = z.infer<typeof EnterpriseTargetingSchema>;

package/dist/schemas/assurance/enterprise-targeting.schema.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Enterprise targeting artifact — required before Implement for strict-assurance risk classes.
+ * Shapes browser outcome proof and release verdict, not marketing copy.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnterpriseTargetingSchema = void 0;
+const zod_1 = require("zod");
+exports.EnterpriseTargetingSchema = zod_1.z
+    .object({
+    productId: zod_1.z.string().min(1),
+    buyer: zod_1.z.string().min(1),
+    operator: zod_1.z.string().min(1),
+    approver: zod_1.z.string().min(1),
+    auditor: zod_1.z.string().min(1),
+    riskHolder: zod_1.z.string().min(1),
+    jobToBeDone: zod_1.z.string().min(1),
+    businessOutcome: zod_1.z.string().min(1),
+    failureConsequence: zod_1.z.string().min(1),
+    trustEvidenceRequired: zod_1.z.array(zod_1.z.string().min(1)).min(1),
+    releaseAcceptanceCriteria: zod_1.z.array(zod_1.z.string().min(1)).min(1),
+    createdAt: zod_1.z.string().datetime(),
+})
+    .strict();

package/dist/schemas/assurance/gate-result.schema.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Domain assurance gate results — Gates 0-10, one status per gate per product per workflow run.
+ */
+import { z } from 'zod';
+export declare const DomainAssuranceGateIdSchema: z.ZodEnum<["riskClassification", "domainTruthBrief", "canonicalKernel", "referenceCases", "physicalQuantitySchemas", "fixtureIntegrity", "livePathVerification", "browserOutcomeProof", "authTenantAudit", "documentationEvidence", "releaseVerdict"]>;
+export type DomainAssuranceGateId = z.infer<typeof DomainAssuranceGateIdSchema>;
+/**
+ * Distinct from workflow/step-gate.schema.ts `GateStatusSchema` (pending/passed/failed/blocked/skipped),
+ * which tracks step-execution state, not domain-assurance evidence verdicts.
+ */
+export declare const DomainAssuranceGateStatusSchema: z.ZodEnum<["pass", "warn", "fail"]>;
+export type DomainAssuranceGateStatus = z.infer<typeof DomainAssuranceGateStatusSchema>;
+export declare const DomainAssuranceGateResultSchema: z.ZodObject<{
+    gateId: z.ZodEnum<["riskClassification", "domainTruthBrief", "canonicalKernel", "referenceCases", "physicalQuantitySchemas", "fixtureIntegrity", "livePathVerification", "browserOutcomeProof", "authTenantAudit", "documentationEvidence", "releaseVerdict"]>;
+    status: z.ZodEnum<["pass", "warn", "fail"]>;
+    evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    blockers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    notes: z.ZodOptional<z.ZodString>;
+    evaluatedAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    status: "warn" | "fail" | "pass";
+    gateId: "referenceCases" | "riskClassification" | "domainTruthBrief" | "canonicalKernel" | "physicalQuantitySchemas" | "fixtureIntegrity" | "livePathVerification" | "browserOutcomeProof" | "authTenantAudit" | "documentationEvidence" | "releaseVerdict";
+    blockers: string[];
+    evidenceRefs: string[];
+    evaluatedAt: string;
+    notes?: string | undefined;
+}, {
+    status: "warn" | "fail" | "pass";
+    gateId: "referenceCases" | "riskClassification" | "domainTruthBrief" | "canonicalKernel" | "physicalQuantitySchemas" | "fixtureIntegrity" | "livePathVerification" | "browserOutcomeProof" | "authTenantAudit" | "documentationEvidence" | "releaseVerdict";
+    evaluatedAt: string;
+    blockers?: string[] | undefined;
+    notes?: string | undefined;
+    evidenceRefs?: string[] | undefined;
+}>;
+export type DomainAssuranceGateResult = z.infer<typeof DomainAssuranceGateResultSchema>;

package/dist/schemas/assurance/gate-result.schema.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Domain assurance gate results — Gates 0-10, one status per gate per product per workflow run.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainAssuranceGateResultSchema = exports.DomainAssuranceGateStatusSchema = exports.DomainAssuranceGateIdSchema = void 0;
+const zod_1 = require("zod");
+exports.DomainAssuranceGateIdSchema = zod_1.z.enum([
+    'riskClassification', // Gate 0
+    'domainTruthBrief', // Gate 1
+    'canonicalKernel', // Gate 2
+    'referenceCases', // Gate 3
+    'physicalQuantitySchemas', // Gate 4
+    'fixtureIntegrity', // Gate 5
+    'livePathVerification', // Gate 6
+    'browserOutcomeProof', // Gate 7
+    'authTenantAudit', // Gate 8
+    'documentationEvidence', // Gate 9
+    'releaseVerdict', // Gate 10
+]);
+/**
+ * Distinct from workflow/step-gate.schema.ts `GateStatusSchema` (pending/passed/failed/blocked/skipped),
+ * which tracks step-execution state, not domain-assurance evidence verdicts.
+ */
+exports.DomainAssuranceGateStatusSchema = zod_1.z.enum(['pass', 'warn', 'fail']);
+exports.DomainAssuranceGateResultSchema = zod_1.z
+    .object({
+    gateId: exports.DomainAssuranceGateIdSchema,
+    status: exports.DomainAssuranceGateStatusSchema,
+    evidenceRefs: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+    blockers: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+    notes: zod_1.z.string().optional(),
+    evaluatedAt: zod_1.z.string().datetime(),
+})
+    .strict();

package/dist/schemas/assurance/index.d.ts

@@ -0,0 +1,13 @@
+export * from './assurance-mode.schema';
+export * from './provider-call-ledger.schema';
+export * from './provider-ledger-response.schema';
+export * from './risk-class.schema';
+export * from './enterprise-targeting.schema';
+export * from './domain-truth-brief.schema';
+export * from './computation-authority-registry.schema';
+export * from './gate-result.schema';
+export * from './domain-assurance-verdict.schema';
+export * from './documentation-evidence.schema';
+export * from './release-verdict.schema';
+export * from './browser-outcome-proof.schema';
+export * from './domain-assurance-evidence-pack.schema';

package/dist/schemas/assurance/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./assurance-mode.schema"), exports);
+__exportStar(require("./provider-call-ledger.schema"), exports);
+__exportStar(require("./provider-ledger-response.schema"), exports);
+// Enterprise Domain Assurance Layer (risk classification → domain kernel → release verdict)
+__exportStar(require("./risk-class.schema"), exports);
+__exportStar(require("./enterprise-targeting.schema"), exports);
+__exportStar(require("./domain-truth-brief.schema"), exports);
+__exportStar(require("./computation-authority-registry.schema"), exports);
+__exportStar(require("./gate-result.schema"), exports);
+__exportStar(require("./domain-assurance-verdict.schema"), exports);
+__exportStar(require("./documentation-evidence.schema"), exports);
+__exportStar(require("./release-verdict.schema"), exports);
+__exportStar(require("./browser-outcome-proof.schema"), exports);
+__exportStar(require("./domain-assurance-evidence-pack.schema"), exports);