@claudexor/schema 1.0.0 → 2.0.0

package/dist/recovery.d.ts

@@ -0,0 +1,515 @@
+import { z } from "zod";
+export declare const JournalRecoveryLocation: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"byte">;
+    byteOffset: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    kind: "byte";
+    byteOffset: number;
+}, {
+    kind: "byte";
+    byteOffset: number;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"cursor">;
+    epoch: z.ZodString;
+    seq: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    kind: "cursor";
+    seq: number;
+    epoch: string;
+}, {
+    kind: "cursor";
+    seq: number;
+    epoch: string;
+}>]>;
+export declare const ControlJournalRecoveryState: z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+    status: z.ZodLiteral<"ready">;
+    discardedTailBytes: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    status: "ready";
+    discardedTailBytes: number;
+}, {
+    status: "ready";
+    discardedTailBytes: number;
+}>, z.ZodObject<{
+    status: z.ZodLiteral<"recovery_required">;
+    location: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"byte">;
+        byteOffset: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        kind: "byte";
+        byteOffset: number;
+    }, {
+        kind: "byte";
+        byteOffset: number;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"cursor">;
+        epoch: z.ZodString;
+        seq: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        kind: "cursor";
+        seq: number;
+        epoch: string;
+    }, {
+        kind: "cursor";
+        seq: number;
+        epoch: string;
+    }>]>;
+    reason: z.ZodString;
+    discardedTailBytes: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    status: "recovery_required";
+    reason: string;
+    discardedTailBytes: number;
+    location: {
+        kind: "byte";
+        byteOffset: number;
+    } | {
+        kind: "cursor";
+        seq: number;
+        epoch: string;
+    };
+}, {
+    status: "recovery_required";
+    reason: string;
+    discardedTailBytes: number;
+    location: {
+        kind: "byte";
+        byteOffset: number;
+    } | {
+        kind: "cursor";
+        seq: number;
+        epoch: string;
+    };
+}>]>;
+export declare const ControlJournalInspection: z.ZodEffects<z.ZodObject<{
+    readonly schemaVersion: z.ZodLiteral<1>;
+    readonly partition: z.ZodString;
+    readonly generation: z.ZodNumber;
+    readonly status: z.ZodEnum<["ready", "recovery_required"]>;
+    readonly recovery: z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+        status: z.ZodLiteral<"ready">;
+        discardedTailBytes: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        status: "ready";
+        discardedTailBytes: number;
+    }, {
+        status: "ready";
+        discardedTailBytes: number;
+    }>, z.ZodObject<{
+        status: z.ZodLiteral<"recovery_required">;
+        location: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"byte">;
+            byteOffset: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            kind: "byte";
+            byteOffset: number;
+        }, {
+            kind: "byte";
+            byteOffset: number;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"cursor">;
+            epoch: z.ZodString;
+            seq: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            kind: "cursor";
+            seq: number;
+            epoch: string;
+        }, {
+            kind: "cursor";
+            seq: number;
+            epoch: string;
+        }>]>;
+        reason: z.ZodString;
+        discardedTailBytes: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        status: "recovery_required";
+        reason: string;
+        discardedTailBytes: number;
+        location: {
+            kind: "byte";
+            byteOffset: number;
+        } | {
+            kind: "cursor";
+            seq: number;
+            epoch: string;
+        };
+    }, {
+        status: "recovery_required";
+        reason: string;
+        discardedTailBytes: number;
+        location: {
+            kind: "byte";
+            byteOffset: number;
+        } | {
+            kind: "cursor";
+            seq: number;
+            epoch: string;
+        };
+    }>]>;
+    readonly fingerprint: z.ZodString;
+    readonly observedAt: z.ZodString;
+    readonly evidenceRefs: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    status: "ready" | "recovery_required";
+    observedAt: string;
+    schemaVersion: 1;
+    evidenceRefs: string[];
+    recovery: {
+        status: "ready";
+        discardedTailBytes: number;
+    } | {
+        status: "recovery_required";
+        reason: string;
+        discardedTailBytes: number;
+        location: {
+            kind: "byte";
+            byteOffset: number;
+        } | {
+            kind: "cursor";
+            seq: number;
+            epoch: string;
+        };
+    };
+    partition: string;
+    generation: number;
+    fingerprint: string;
+}, {
+    status: "ready" | "recovery_required";
+    observedAt: string;
+    schemaVersion: 1;
+    evidenceRefs: string[];
+    recovery: {
+        status: "ready";
+        discardedTailBytes: number;
+    } | {
+        status: "recovery_required";
+        reason: string;
+        discardedTailBytes: number;
+        location: {
+            kind: "byte";
+            byteOffset: number;
+        } | {
+            kind: "cursor";
+            seq: number;
+            epoch: string;
+        };
+    };
+    partition: string;
+    generation: number;
+    fingerprint: string;
+}>, {
+    status: "ready" | "recovery_required";
+    observedAt: string;
+    schemaVersion: 1;
+    evidenceRefs: string[];
+    recovery: {
+        status: "ready";
+        discardedTailBytes: number;
+    } | {
+        status: "recovery_required";
+        reason: string;
+        discardedTailBytes: number;
+        location: {
+            kind: "byte";
+            byteOffset: number;
+        } | {
+            kind: "cursor";
+            seq: number;
+            epoch: string;
+        };
+    };
+    partition: string;
+    generation: number;
+    fingerprint: string;
+}, {
+    status: "ready" | "recovery_required";
+    observedAt: string;
+    schemaVersion: 1;
+    evidenceRefs: string[];
+    recovery: {
+        status: "ready";
+        discardedTailBytes: number;
+    } | {
+        status: "recovery_required";
+        reason: string;
+        discardedTailBytes: number;
+        location: {
+            kind: "byte";
+            byteOffset: number;
+        } | {
+            kind: "cursor";
+            seq: number;
+            epoch: string;
+        };
+    };
+    partition: string;
+    generation: number;
+    fingerprint: string;
+}>;
+export type ControlJournalInspection = z.infer<typeof ControlJournalInspection>;
+export declare const ControlJournalValidation: z.ZodEffects<z.ZodObject<{
+    projectionStatus: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodEnum<["valid", "invalid"]>;
+        detail: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        status: "valid" | "invalid";
+        detail: string | null;
+        name: string;
+    }, {
+        status: "valid" | "invalid";
+        detail: string | null;
+        name: string;
+    }>, "many">;
+    schemaVersion: z.ZodLiteral<1>;
+    partition: z.ZodString;
+    generation: z.ZodNumber;
+    status: z.ZodEnum<["ready", "recovery_required"]>;
+    recovery: z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+        status: z.ZodLiteral<"ready">;
+        discardedTailBytes: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        status: "ready";
+        discardedTailBytes: number;
+    }, {
+        status: "ready";
+        discardedTailBytes: number;
+    }>, z.ZodObject<{
+        status: z.ZodLiteral<"recovery_required">;
+        location: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"byte">;
+            byteOffset: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            kind: "byte";
+            byteOffset: number;
+        }, {
+            kind: "byte";
+            byteOffset: number;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"cursor">;
+            epoch: z.ZodString;
+            seq: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            kind: "cursor";
+            seq: number;
+            epoch: string;
+        }, {
+            kind: "cursor";
+            seq: number;
+            epoch: string;
+        }>]>;
+        reason: z.ZodString;
+        discardedTailBytes: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        status: "recovery_required";
+        reason: string;
+        discardedTailBytes: number;
+        location: {
+            kind: "byte";
+            byteOffset: number;
+        } | {
+            kind: "cursor";
+            seq: number;
+            epoch: string;
+        };
+    }, {
+        status: "recovery_required";
+        reason: string;
+        discardedTailBytes: number;
+        location: {
+            kind: "byte";
+            byteOffset: number;
+        } | {
+            kind: "cursor";
+            seq: number;
+            epoch: string;
+        };
+    }>]>;
+    fingerprint: z.ZodString;
+    observedAt: z.ZodString;
+    evidenceRefs: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    status: "ready" | "recovery_required";
+    observedAt: string;
+    schemaVersion: 1;
+    evidenceRefs: string[];
+    recovery: {
+        status: "ready";
+        discardedTailBytes: number;
+    } | {
+        status: "recovery_required";
+        reason: string;
+        discardedTailBytes: number;
+        location: {
+            kind: "byte";
+            byteOffset: number;
+        } | {
+            kind: "cursor";
+            seq: number;
+            epoch: string;
+        };
+    };
+    partition: string;
+    generation: number;
+    fingerprint: string;
+    projectionStatus: {
+        status: "valid" | "invalid";
+        detail: string | null;
+        name: string;
+    }[];
+}, {
+    status: "ready" | "recovery_required";
+    observedAt: string;
+    schemaVersion: 1;
+    evidenceRefs: string[];
+    recovery: {
+        status: "ready";
+        discardedTailBytes: number;
+    } | {
+        status: "recovery_required";
+        reason: string;
+        discardedTailBytes: number;
+        location: {
+            kind: "byte";
+            byteOffset: number;
+        } | {
+            kind: "cursor";
+            seq: number;
+            epoch: string;
+        };
+    };
+    partition: string;
+    generation: number;
+    fingerprint: string;
+    projectionStatus: {
+        status: "valid" | "invalid";
+        detail: string | null;
+        name: string;
+    }[];
+}>, {
+    status: "ready" | "recovery_required";
+    observedAt: string;
+    schemaVersion: 1;
+    evidenceRefs: string[];
+    recovery: {
+        status: "ready";
+        discardedTailBytes: number;
+    } | {
+        status: "recovery_required";
+        reason: string;
+        discardedTailBytes: number;
+        location: {
+            kind: "byte";
+            byteOffset: number;
+        } | {
+            kind: "cursor";
+            seq: number;
+            epoch: string;
+        };
+    };
+    partition: string;
+    generation: number;
+    fingerprint: string;
+    projectionStatus: {
+        status: "valid" | "invalid";
+        detail: string | null;
+        name: string;
+    }[];
+}, {
+    status: "ready" | "recovery_required";
+    observedAt: string;
+    schemaVersion: 1;
+    evidenceRefs: string[];
+    recovery: {
+        status: "ready";
+        discardedTailBytes: number;
+    } | {
+        status: "recovery_required";
+        reason: string;
+        discardedTailBytes: number;
+        location: {
+            kind: "byte";
+            byteOffset: number;
+        } | {
+            kind: "cursor";
+            seq: number;
+            epoch: string;
+        };
+    };
+    partition: string;
+    generation: number;
+    fingerprint: string;
+    projectionStatus: {
+        status: "valid" | "invalid";
+        detail: string | null;
+        name: string;
+    }[];
+}>;
+export type ControlJournalValidation = z.infer<typeof ControlJournalValidation>;
+export declare const ControlJournalExportReceipt: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    exportId: z.ZodString;
+    partition: z.ZodString;
+    fingerprint: z.ZodString;
+    bundlePath: z.ZodString;
+    manifestSha256: z.ZodString;
+    createdAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: 1;
+    createdAt: string;
+    partition: string;
+    fingerprint: string;
+    exportId: string;
+    bundlePath: string;
+    manifestSha256: string;
+}, {
+    schemaVersion: 1;
+    createdAt: string;
+    partition: string;
+    fingerprint: string;
+    exportId: string;
+    bundlePath: string;
+    manifestSha256: string;
+}>;
+export type ControlJournalExportReceipt = z.infer<typeof ControlJournalExportReceipt>;
+export declare const ControlJournalQuarantineRequest: z.ZodObject<{
+    expectedFingerprint: z.ZodString;
+    confirmation: z.ZodLiteral<"quarantine_and_start_fresh">;
+}, "strict", z.ZodTypeAny, {
+    expectedFingerprint: string;
+    confirmation: "quarantine_and_start_fresh";
+}, {
+    expectedFingerprint: string;
+    confirmation: "quarantine_and_start_fresh";
+}>;
+export type ControlJournalQuarantineRequest = z.infer<typeof ControlJournalQuarantineRequest>;
+export declare const ControlJournalQuarantineReceipt: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    operationId: z.ZodString;
+    partition: z.ZodString;
+    previousFingerprint: z.ZodString;
+    quarantineArtifactId: z.ZodString;
+    quarantinePath: z.ZodString;
+    newEpoch: z.ZodString;
+    completedAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: 1;
+    completedAt: string;
+    partition: string;
+    operationId: string;
+    previousFingerprint: string;
+    quarantineArtifactId: string;
+    quarantinePath: string;
+    newEpoch: string;
+}, {
+    schemaVersion: 1;
+    completedAt: string;
+    partition: string;
+    operationId: string;
+    previousFingerprint: string;
+    quarantineArtifactId: string;
+    quarantinePath: string;
+    newEpoch: string;
+}>;
+export type ControlJournalQuarantineReceipt = z.infer<typeof ControlJournalQuarantineReceipt>;
+//# sourceMappingURL=recovery.d.ts.map

package/dist/recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../src/recovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;IASlC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAYtC,CAAC;AA6BH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGQ,CAAC;AAC9C,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEhF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcQ,CAAC;AAC9C,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEhF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;EAU7B,CAAC;AACZ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEtF,eAAO,MAAM,+BAA+B;;;;;;;;;EAKjC,CAAC;AACZ,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAE9F,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWjC,CAAC;AACZ,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC"}

package/dist/recovery.js

@@ -0,0 +1,93 @@
+import { z } from "zod";
+const Sha256Hex = z.string().regex(/^[a-f0-9]{64}$/);
+const Timestamp = z.string().datetime({ offset: true });
+const JournalPartition = z.string().trim().min(1).max(256);
+export const JournalRecoveryLocation = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("byte"), byteOffset: z.number().int().nonnegative() }).strict(),
+    z
+        .object({
+        kind: z.literal("cursor"),
+        epoch: z.string().min(1),
+        seq: z.number().int().nonnegative(),
+    })
+        .strict(),
+]);
+export const ControlJournalRecoveryState = z.discriminatedUnion("status", [
+    z
+        .object({ status: z.literal("ready"), discardedTailBytes: z.number().int().nonnegative() })
+        .strict(),
+    z
+        .object({
+        status: z.literal("recovery_required"),
+        location: JournalRecoveryLocation,
+        reason: z.string().min(1),
+        discardedTailBytes: z.number().int().nonnegative(),
+    })
+        .strict(),
+]);
+const JournalInspectionFields = {
+    schemaVersion: z.literal(1),
+    partition: JournalPartition,
+    generation: z.number().int().nonnegative(),
+    status: z.enum(["ready", "recovery_required"]),
+    recovery: ControlJournalRecoveryState,
+    fingerprint: Sha256Hex,
+    observedAt: Timestamp,
+    evidenceRefs: z.array(z.string().min(1)).min(1),
+};
+function requireMatchingRecoveryStatus(value, context) {
+    if (value.status !== value.recovery.status) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["status"],
+            message: "inspection status must match recovery status",
+        });
+    }
+}
+export const ControlJournalInspection = z
+    .object(JournalInspectionFields)
+    .strict()
+    .superRefine(requireMatchingRecoveryStatus);
+export const ControlJournalValidation = z
+    .object({
+    ...JournalInspectionFields,
+    projectionStatus: z.array(z
+        .object({
+        name: z.string().min(1),
+        status: z.enum(["valid", "invalid"]),
+        detail: z.string().nullable(),
+    })
+        .strict()),
+})
+    .strict()
+    .superRefine(requireMatchingRecoveryStatus);
+export const ControlJournalExportReceipt = z
+    .object({
+    schemaVersion: z.literal(1),
+    exportId: z.string().min(1),
+    partition: JournalPartition,
+    fingerprint: Sha256Hex,
+    bundlePath: z.string().min(1),
+    manifestSha256: Sha256Hex,
+    createdAt: Timestamp,
+})
+    .strict();
+export const ControlJournalQuarantineRequest = z
+    .object({
+    expectedFingerprint: Sha256Hex,
+    confirmation: z.literal("quarantine_and_start_fresh"),
+})
+    .strict();
+export const ControlJournalQuarantineReceipt = z
+    .object({
+    schemaVersion: z.literal(1),
+    operationId: z.string().uuid(),
+    partition: JournalPartition,
+    previousFingerprint: Sha256Hex,
+    quarantineArtifactId: z.string().min(1),
+    quarantinePath: z.string().min(1),
+    newEpoch: z.string().min(1),
+    completedAt: Timestamp,
+})
+    .strict();
+//# sourceMappingURL=recovery.js.map

package/dist/recovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.js","sourceRoot":"","sources":["../src/recovery.ts"],"names":[],"mappings":"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"}

package/dist/request-requirements.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+/** Why one selected lane did or did not receive a requested capability. */
+export declare const RequestRequirementReason: z.ZodEnum<["not_requested", "effective", "manifest_unsupported", "web_policy_off", "access_profile_incompatible"]>;
+export type RequestRequirementReason = z.infer<typeof RequestRequirementReason>;
+/**
+ * Preflight truth for one requested capability on one selected harness lane.
+ * A lane may remain eligible for the run while a mixed-pool capability is not
+ * effective there; consumers must use `effective`, never infer from manifest.
+ */
+export declare const RequestRequirementResolution: z.ZodObject<{
+    capability: z.ZodLiteral<"browser">;
+    harness_id: z.ZodString;
+    eligible: z.ZodBoolean;
+    requested: z.ZodBoolean;
+    effective: z.ZodBoolean;
+    reason: z.ZodEnum<["not_requested", "effective", "manifest_unsupported", "web_policy_off", "access_profile_incompatible"]>;
+    evidence_refs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    requested: boolean;
+    effective: boolean;
+    reason: "effective" | "not_requested" | "manifest_unsupported" | "web_policy_off" | "access_profile_incompatible";
+    evidence_refs: string[];
+    harness_id: string;
+    eligible: boolean;
+    capability: "browser";
+}, {
+    requested: boolean;
+    effective: boolean;
+    reason: "effective" | "not_requested" | "manifest_unsupported" | "web_policy_off" | "access_profile_incompatible";
+    harness_id: string;
+    eligible: boolean;
+    capability: "browser";
+    evidence_refs?: string[] | undefined;
+}>;
+export type RequestRequirementResolution = z.infer<typeof RequestRequirementResolution>;
+//# sourceMappingURL=request-requirements.d.ts.map

package/dist/request-requirements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-requirements.d.ts","sourceRoot":"","sources":["../src/request-requirements.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,2EAA2E;AAC3E,eAAO,MAAM,wBAAwB,oHAMnC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEhF;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;EAUoD,CAAC;AAC9F,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC"}

package/dist/request-requirements.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+/** Why one selected lane did or did not receive a requested capability. */
+export const RequestRequirementReason = z.enum([
+    "not_requested",
+    "effective",
+    "manifest_unsupported",
+    "web_policy_off",
+    "access_profile_incompatible",
+]);
+/**
+ * Preflight truth for one requested capability on one selected harness lane.
+ * A lane may remain eligible for the run while a mixed-pool capability is not
+ * effective there; consumers must use `effective`, never infer from manifest.
+ */
+export const RequestRequirementResolution = z
+    .object({
+    capability: z.literal("browser"),
+    harness_id: z.string().min(1),
+    eligible: z.boolean(),
+    requested: z.boolean(),
+    effective: z.boolean(),
+    reason: RequestRequirementReason,
+    evidence_refs: z.array(z.string()).default([]),
+})
+    .describe("Preflight resolution of one requested capability on one selected harness lane.");
+//# sourceMappingURL=request-requirements.js.map

package/dist/request-requirements.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-requirements.js","sourceRoot":"","sources":["../src/request-requirements.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,2EAA2E;AAC3E,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,IAAI,CAAC;IAC7C,eAAe;IACf,WAAW;IACX,sBAAsB;IACtB,gBAAgB;IAChB,6BAA6B;CAC9B,CAAC,CAAC;AAGH;;;;GAIG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC;KAC1C,MAAM,CAAC;IACN,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;IAChC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7B,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE;IACrB,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE;IACtB,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE;IACtB,MAAM,EAAE,wBAAwB;IAChC,aAAa,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;CAC/C,CAAC;KACD,QAAQ,CAAC,gFAAgF,CAAC,CAAC"}