@neuraloom/contracts 0.0.0-stage → 0.1.22

package/dist/schemas/api/project-model-usage-query.schema.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+/**
+ * Query params for GET /api/projects/:id/model-usage (validated before defaults applied).
+ */
+export declare const ProjectModelUsageQueryPartialSchema: z.ZodObject<{
+    since: z.ZodEffects<z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>, string | undefined, unknown>;
+    until: z.ZodEffects<z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>, string | undefined, unknown>;
+    limit: z.ZodEffects<z.ZodOptional<z.ZodNumber>, number | undefined, unknown>;
+}, "strip", z.ZodTypeAny, {
+    limit?: number | undefined;
+    since?: string | undefined;
+    until?: string | undefined;
+}, {
+    limit?: unknown;
+    since?: unknown;
+    until?: unknown;
+}>;
+export type ProjectModelUsageQueryPartial = z.infer<typeof ProjectModelUsageQueryPartialSchema>;
+export declare function defaultSinceUtcMonthStartIso(now: Date): string;
+export declare function resolveProjectModelUsageQuery(parsed: ProjectModelUsageQueryPartial, now: Date): {
+    since: string;
+    until: string;
+    limit: number;
+};

package/dist/schemas/api/project-model-usage-query.schema.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectModelUsageQueryPartialSchema = void 0;
+exports.defaultSinceUtcMonthStartIso = defaultSinceUtcMonthStartIso;
+exports.resolveProjectModelUsageQuery = resolveProjectModelUsageQuery;
+const zod_1 = require("zod");
+function isoDateParseable(s) {
+    return !Number.isNaN(Date.parse(s));
+}
+/**
+ * Query params for GET /api/projects/:id/model-usage (validated before defaults applied).
+ */
+exports.ProjectModelUsageQueryPartialSchema = zod_1.z.object({
+    since: zod_1.z.preprocess((v) => (v === "" ? undefined : v), zod_1.z
+        .string()
+        .optional()
+        .refine((s) => s === undefined || isoDateParseable(s), {
+        message: "since must be a valid ISO date string",
+    })),
+    until: zod_1.z.preprocess((v) => (v === "" ? undefined : v), zod_1.z
+        .string()
+        .optional()
+        .refine((s) => s === undefined || isoDateParseable(s), {
+        message: "until must be a valid ISO date string",
+    })),
+    limit: zod_1.z.preprocess((v) => {
+        if (v === undefined || v === null || v === "")
+            return undefined;
+        const n = typeof v === "string" ? Number(v) : Number(v);
+        return Number.isFinite(n) ? n : undefined;
+    }, zod_1.z.number().int().min(1).max(100).optional()),
+});
+function defaultSinceUtcMonthStartIso(now) {
+    return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1)).toISOString();
+}
+function resolveProjectModelUsageQuery(parsed, now) {
+    return {
+        since: parsed.since ?? defaultSinceUtcMonthStartIso(now),
+        until: parsed.until ?? now.toISOString(),
+        limit: parsed.limit ?? 25,
+    };
+}

package/dist/schemas/api/specs-list-response.schema.d.ts

@@ -0,0 +1,78 @@
+import { z } from "zod";
+/** Row shape from GET /api/specs project listing (camelCase). */
+export declare const SpecApiListRowSchema: z.ZodObject<{
+    id: z.ZodString;
+    projectId: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    requirements: z.ZodEffects<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodNull, z.ZodUndefined]>, string[], string[] | null | undefined>;
+    acceptanceCriteria: z.ZodEffects<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodNull, z.ZodUndefined]>, string[], string[] | null | undefined>;
+    priority: z.ZodEnum<["low", "medium", "high", "critical"]>;
+    status: z.ZodEnum<["draft", "validated", "approved", "rejected", "superseded"]>;
+    createdBy: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+    description: string;
+    status: "rejected" | "approved" | "draft" | "superseded" | "validated";
+    projectId: string;
+    createdAt: string;
+    priority: "critical" | "low" | "medium" | "high";
+    updatedAt: string;
+    requirements: string[];
+    acceptanceCriteria: string[];
+    createdBy: string;
+}, {
+    id: string;
+    title: string;
+    description: string;
+    status: "rejected" | "approved" | "draft" | "superseded" | "validated";
+    projectId: string;
+    createdAt: string;
+    priority: "critical" | "low" | "medium" | "high";
+    updatedAt: string;
+    createdBy: string;
+    requirements?: string[] | null | undefined;
+    acceptanceCriteria?: string[] | null | undefined;
+}>;
+export type SpecApiListRow = z.infer<typeof SpecApiListRowSchema>;
+export declare const SpecsListApiResponseSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    projectId: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    requirements: z.ZodEffects<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodNull, z.ZodUndefined]>, string[], string[] | null | undefined>;
+    acceptanceCriteria: z.ZodEffects<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodNull, z.ZodUndefined]>, string[], string[] | null | undefined>;
+    priority: z.ZodEnum<["low", "medium", "high", "critical"]>;
+    status: z.ZodEnum<["draft", "validated", "approved", "rejected", "superseded"]>;
+    createdBy: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+    description: string;
+    status: "rejected" | "approved" | "draft" | "superseded" | "validated";
+    projectId: string;
+    createdAt: string;
+    priority: "critical" | "low" | "medium" | "high";
+    updatedAt: string;
+    requirements: string[];
+    acceptanceCriteria: string[];
+    createdBy: string;
+}, {
+    id: string;
+    title: string;
+    description: string;
+    status: "rejected" | "approved" | "draft" | "superseded" | "validated";
+    projectId: string;
+    createdAt: string;
+    priority: "critical" | "low" | "medium" | "high";
+    updatedAt: string;
+    createdBy: string;
+    requirements?: string[] | null | undefined;
+    acceptanceCriteria?: string[] | null | undefined;
+}>, "many">;
+export type SpecsListApiResponse = z.infer<typeof SpecsListApiResponseSchema>;

package/dist/schemas/api/specs-list-response.schema.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecsListApiResponseSchema = exports.SpecApiListRowSchema = void 0;
+const zod_1 = require("zod");
+/** Normalizes specs JSON/array columns returned from GET /api/specs */
+const JsonbStringArraySchema = zod_1.z
+    .union([zod_1.z.array(zod_1.z.string()), zod_1.z.null(), zod_1.z.undefined()])
+    .transform((v) => (Array.isArray(v) ? v : []));
+/** Row shape from GET /api/specs project listing (camelCase). */
+exports.SpecApiListRowSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    projectId: zod_1.z.string().uuid(),
+    title: zod_1.z.string(),
+    description: zod_1.z.string(),
+    requirements: JsonbStringArraySchema,
+    acceptanceCriteria: JsonbStringArraySchema,
+    priority: zod_1.z.enum(["low", "medium", "high", "critical"]),
+    status: zod_1.z.enum(["draft", "validated", "approved", "rejected", "superseded"]),
+    createdBy: zod_1.z.string().uuid(),
+    createdAt: zod_1.z.string(),
+    updatedAt: zod_1.z.string(),
+});
+exports.SpecsListApiResponseSchema = zod_1.z.array(exports.SpecApiListRowSchema);

package/dist/schemas/api-envelope.schema.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Canonical HTTP API envelope (matches baseApiHandler and typedFetch expectations).
+ */
+import { z } from "zod";
+import type { ApiError } from "../types/index";
+export declare const ApiErrorSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    message: string;
+    details?: Record<string, unknown> | undefined;
+}, {
+    code: string;
+    message: string;
+    details?: Record<string, unknown> | undefined;
+}>;
+export declare const ApiSuccessEnvelopeSchema: <T extends z.ZodTypeAny>(dataSchema: T) => z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: T;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    success: z.ZodLiteral<true>;
+    data: T;
+    timestamp: z.ZodString;
+}>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<{
+    success: z.ZodLiteral<true>;
+    data: T;
+    timestamp: z.ZodString;
+}> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never>;
+export declare const ApiFailureEnvelopeSchema: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    }, {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    }>;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    };
+    timestamp: string;
+}, {
+    success: false;
+    error: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    };
+    timestamp: string;
+}>;
+export declare const ApiResponseSchema: <T extends z.ZodTypeAny>(dataSchema: T) => z.ZodDiscriminatedUnion<"success", [z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: T;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    success: z.ZodLiteral<true>;
+    data: T;
+    timestamp: z.ZodString;
+}>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<{
+    success: z.ZodLiteral<true>;
+    data: T;
+    timestamp: z.ZodString;
+}> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never>, z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    }, {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    }>;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    };
+    timestamp: string;
+}, {
+    success: false;
+    error: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    };
+    timestamp: string;
+}>]>;
+export declare function buildApiSuccessResponse<T>(data: T): {
+    success: true;
+    data: T;
+    timestamp: string;
+};
+export declare function buildApiFailureResponse(error: ApiError): {
+    success: false;
+    error: ApiError;
+    timestamp: string;
+};
+/**
+ * Structured-output validation (#429): Zod parse with canonical failure envelope.
+ */
+export declare function parseAiArtifactToApiResponse<T>(schema: z.ZodType<T>, payload: unknown, message?: string): {
+    success: true;
+    data: T;
+    timestamp: string;
+} | {
+    success: false;
+    error: ApiError;
+    timestamp: string;
+};

package/dist/schemas/api-envelope.schema.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiResponseSchema = exports.ApiFailureEnvelopeSchema = exports.ApiSuccessEnvelopeSchema = exports.ApiErrorSchema = void 0;
+exports.buildApiSuccessResponse = buildApiSuccessResponse;
+exports.buildApiFailureResponse = buildApiFailureResponse;
+exports.parseAiArtifactToApiResponse = parseAiArtifactToApiResponse;
+/**
+ * Canonical HTTP API envelope (matches baseApiHandler and typedFetch expectations).
+ */
+const zod_1 = require("zod");
+const DateTimeSchema = zod_1.z.string().datetime();
+exports.ApiErrorSchema = zod_1.z.object({
+    code: zod_1.z.string().min(1).max(50),
+    message: zod_1.z.string().min(1).max(500),
+    details: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+});
+const ApiSuccessEnvelopeSchema = (dataSchema) => zod_1.z.object({
+    success: zod_1.z.literal(true),
+    data: dataSchema,
+    timestamp: DateTimeSchema,
+});
+exports.ApiSuccessEnvelopeSchema = ApiSuccessEnvelopeSchema;
+exports.ApiFailureEnvelopeSchema = zod_1.z.object({
+    success: zod_1.z.literal(false),
+    error: exports.ApiErrorSchema,
+    timestamp: DateTimeSchema,
+});
+const ApiResponseSchema = (dataSchema) => zod_1.z.discriminatedUnion("success", [
+    (0, exports.ApiSuccessEnvelopeSchema)(dataSchema),
+    exports.ApiFailureEnvelopeSchema,
+]);
+exports.ApiResponseSchema = ApiResponseSchema;
+function buildApiSuccessResponse(data) {
+    return {
+        success: true,
+        data,
+        timestamp: new Date().toISOString(),
+    };
+}
+function buildApiFailureResponse(error) {
+    return {
+        success: false,
+        error,
+        timestamp: new Date().toISOString(),
+    };
+}
+/**
+ * Structured-output validation (#429): Zod parse with canonical failure envelope.
+ */
+function parseAiArtifactToApiResponse(schema, payload, message) {
+    const parsed = schema.safeParse(payload);
+    if (parsed.success) {
+        return buildApiSuccessResponse(parsed.data);
+    }
+    return buildApiFailureResponse({
+        code: "LLM_OUTPUT_VALIDATION_FAILED",
+        message: message ?? "Structured output validation failed",
+        details: { issues: parsed.error.issues },
+    });
+}

package/dist/schemas/artifacts/artifact-upload-proxy.schema.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+/**
+ * POST /api/artifacts/upload — proxy JSON body forwarded to `/api/backend/artifacts/upload`.
+ */
+export declare const ArtifactUploadProxyRequestBodySchema: z.ZodObject<{
+    projectId: z.ZodString;
+    agentId: z.ZodString;
+    artifactType: z.ZodString;
+    fileName: z.ZodString;
+    content: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    projectId: string;
+    content: string;
+    artifactType: string;
+    agentId: string;
+    fileName: string;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    projectId: string;
+    content: string;
+    artifactType: string;
+    agentId: string;
+    fileName: string;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export type ArtifactUploadProxyRequestBody = z.infer<typeof ArtifactUploadProxyRequestBodySchema>;

package/dist/schemas/artifacts/artifact-upload-proxy.schema.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArtifactUploadProxyRequestBodySchema = void 0;
+const zod_1 = require("zod");
+/**
+ * POST /api/artifacts/upload — proxy JSON body forwarded to `/api/backend/artifacts/upload`.
+ */
+exports.ArtifactUploadProxyRequestBodySchema = zod_1.z.object({
+    projectId: zod_1.z.string().uuid(),
+    agentId: zod_1.z.string().min(1),
+    artifactType: zod_1.z.string().min(1),
+    fileName: zod_1.z.string().min(1),
+    content: zod_1.z.string().min(1),
+    metadata: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+});

package/dist/schemas/assurance/assurance-mode.schema.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+/** OpenAI / workflow assurance mode — dry-run skips provider network I/O. */
+export declare const NeuraloomAiModeSchema: z.ZodEnum<["dry-run", "live"]>;
+export type NeuraloomAiMode = z.infer<typeof NeuraloomAiModeSchema>;
+/** Providers that may be disabled via DISABLE_FILM_PROVIDER CSV. */
+export declare const AssuranceDisabledFilmProviderSchema: z.ZodEnum<["runway", "comfyui", "elevenlabs"]>;
+export type AssuranceDisabledFilmProvider = z.infer<typeof AssuranceDisabledFilmProviderSchema>;
+export declare const AssuranceModeConfigSchema: z.ZodObject<{
+    aiMode: z.ZodEnum<["dry-run", "live"]>;
+    /** Env override cap; null when NEURALOOM_MAX_USD_PER_RUN unset. */
+    maxUsdPerRun: z.ZodNullable<z.ZodNumber>;
+    disabledFilmProviders: z.ZodArray<z.ZodEnum<["runway", "comfyui", "elevenlabs"]>, "many">;
+    blockCommunityPublish: z.ZodBoolean;
+    /**
+     * When false (default in assurance mode), blocks Runway, ElevenLabs, and ComfyUI
+     * API calls to prevent accidental expensive media generation during OC/PR runs.
+     * Set NEURALOOM_ALLOW_EXPENSIVE_MEDIA=true to enable in assurance mode.
+     */
+    allowExpensiveMedia: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    aiMode: "dry-run" | "live";
+    maxUsdPerRun: number | null;
+    disabledFilmProviders: ("elevenlabs" | "runway" | "comfyui")[];
+    blockCommunityPublish: boolean;
+    allowExpensiveMedia: boolean;
+}, {
+    aiMode: "dry-run" | "live";
+    maxUsdPerRun: number | null;
+    disabledFilmProviders: ("elevenlabs" | "runway" | "comfyui")[];
+    blockCommunityPublish: boolean;
+    allowExpensiveMedia: boolean;
+}>;
+export type AssuranceModeConfig = z.infer<typeof AssuranceModeConfigSchema>;

package/dist/schemas/assurance/assurance-mode.schema.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssuranceModeConfigSchema = exports.AssuranceDisabledFilmProviderSchema = exports.NeuraloomAiModeSchema = void 0;
+const zod_1 = require("zod");
+/** OpenAI / workflow assurance mode — dry-run skips provider network I/O. */
+exports.NeuraloomAiModeSchema = zod_1.z.enum(['dry-run', 'live']);
+/** Providers that may be disabled via DISABLE_FILM_PROVIDER CSV. */
+exports.AssuranceDisabledFilmProviderSchema = zod_1.z.enum([
+    'runway',
+    'comfyui',
+    'elevenlabs',
+]);
+exports.AssuranceModeConfigSchema = zod_1.z.object({
+    aiMode: exports.NeuraloomAiModeSchema,
+    /** Env override cap; null when NEURALOOM_MAX_USD_PER_RUN unset. */
+    maxUsdPerRun: zod_1.z.number().positive().nullable(),
+    disabledFilmProviders: zod_1.z.array(exports.AssuranceDisabledFilmProviderSchema),
+    blockCommunityPublish: zod_1.z.boolean(),
+    /**
+     * When false (default in assurance mode), blocks Runway, ElevenLabs, and ComfyUI
+     * API calls to prevent accidental expensive media generation during OC/PR runs.
+     * Set NEURALOOM_ALLOW_EXPENSIVE_MEDIA=true to enable in assurance mode.
+     */
+    allowExpensiveMedia: zod_1.z.boolean(),
+});

package/dist/schemas/assurance/browser-outcome-proof.schema.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Browser Outcome Proof (Gate 7) — upgrades browser QA from "did the page render" to
+ * "does the visible/exported result match the canonical domain-kernel recomputation".
+ *
+ * Metrology failure this closes: the shipped browser probe scored `domain_specific` on
+ * keyword-hit count alone (3+ domain terms in page text), so a page showing a WRONG
+ * residual/position still "passed". An outcome assertion instead compares the value the
+ * user actually sees/exports against an independently computed expected value.
+ */
+import { z } from 'zod';
+/** Input shape — what a Playwright/browser-qa step captures before scoring. */
+export declare const BrowserOutcomeAssertionInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    /** Route or UI surface where the value is observed (e.g. exported report, results table). */
+    source: z.ZodString;
+    unit: z.ZodOptional<z.ZodString>;
+    expectedValue: z.ZodNumber;
+    actualValue: z.ZodNumber;
+    toleranceAbs: z.ZodNumber;
+    independentlyDerivedFrom: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    description: string;
+    source: string;
+    independentlyDerivedFrom: string;
+    expectedValue: number;
+    actualValue: number;
+    toleranceAbs: number;
+    unit?: string | undefined;
+}, {
+    id: string;
+    description: string;
+    source: string;
+    independentlyDerivedFrom: string;
+    expectedValue: number;
+    actualValue: number;
+    toleranceAbs: number;
+    unit?: string | undefined;
+}>;
+export type BrowserOutcomeAssertionInput = z.infer<typeof BrowserOutcomeAssertionInputSchema>;
+/** Scored assertion — the input plus the pass/fail verdict, persisted as evidence. */
+export declare const BrowserOutcomeAssertionSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    /** Route or UI surface where the value is observed (e.g. exported report, results table). */
+    source: z.ZodString;
+    unit: z.ZodOptional<z.ZodString>;
+    expectedValue: z.ZodNumber;
+    actualValue: z.ZodNumber;
+    toleranceAbs: z.ZodNumber;
+    independentlyDerivedFrom: z.ZodString;
+} & {
+    passed: z.ZodBoolean;
+    deltaAbs: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    description: string;
+    source: string;
+    passed: boolean;
+    independentlyDerivedFrom: string;
+    expectedValue: number;
+    actualValue: number;
+    toleranceAbs: number;
+    deltaAbs: number;
+    unit?: string | undefined;
+}, {
+    id: string;
+    description: string;
+    source: string;
+    passed: boolean;
+    independentlyDerivedFrom: string;
+    expectedValue: number;
+    actualValue: number;
+    toleranceAbs: number;
+    deltaAbs: number;
+    unit?: string | undefined;
+}>;
+export type BrowserOutcomeAssertion = z.infer<typeof BrowserOutcomeAssertionSchema>;
+export declare const BrowserOutcomeProofResultSchema: z.ZodObject<{
+    productId: z.ZodString;
+    workflowRunId: z.ZodString;
+    assertions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        /** Route or UI surface where the value is observed (e.g. exported report, results table). */
+        source: z.ZodString;
+        unit: z.ZodOptional<z.ZodString>;
+        expectedValue: z.ZodNumber;
+        actualValue: z.ZodNumber;
+        toleranceAbs: z.ZodNumber;
+        independentlyDerivedFrom: z.ZodString;
+    } & {
+        passed: z.ZodBoolean;
+        deltaAbs: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        description: string;
+        source: string;
+        passed: boolean;
+        independentlyDerivedFrom: string;
+        expectedValue: number;
+        actualValue: number;
+        toleranceAbs: number;
+        deltaAbs: number;
+        unit?: string | undefined;
+    }, {
+        id: string;
+        description: string;
+        source: string;
+        passed: boolean;
+        independentlyDerivedFrom: string;
+        expectedValue: number;
+        actualValue: number;
+        toleranceAbs: number;
+        deltaAbs: number;
+        unit?: string | undefined;
+    }>, "many">;
+    allPassed: z.ZodBoolean;
+    evaluatedAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    productId: string;
+    evaluatedAt: string;
+    workflowRunId: string;
+    assertions: {
+        id: string;
+        description: string;
+        source: string;
+        passed: boolean;
+        independentlyDerivedFrom: string;
+        expectedValue: number;
+        actualValue: number;
+        toleranceAbs: number;
+        deltaAbs: number;
+        unit?: string | undefined;
+    }[];
+    allPassed: boolean;
+}, {
+    productId: string;
+    evaluatedAt: string;
+    workflowRunId: string;
+    assertions: {
+        id: string;
+        description: string;
+        source: string;
+        passed: boolean;
+        independentlyDerivedFrom: string;
+        expectedValue: number;
+        actualValue: number;
+        toleranceAbs: number;
+        deltaAbs: number;
+        unit?: string | undefined;
+    }[];
+    allPassed: boolean;
+}>;
+export type BrowserOutcomeProofResult = z.infer<typeof BrowserOutcomeProofResultSchema>;
+/** Scores raw assertion inputs (e.g. captured by a browser-qa/Playwright step) into a
+ * Gate 7 result. Pure — no network/DOM access — so it is independently unit-testable. */
+export declare function evaluateBrowserOutcomeAssertions(args: {
+    productId: string;
+    workflowRunId: string;
+    assertions: readonly BrowserOutcomeAssertionInput[];
+    evaluatedAt: string;
+}): BrowserOutcomeProofResult;