@claudexor/schema 1.0.1 → 2.1.1

package/dist/readiness.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { AdapterStatus, ConformanceCheck, HarnessManifest } from "./harness.js";
+import { AuthSourceReadiness } from "./auth.js";
+/**
+ * ONE display-ready readiness check (W4.7 sol #18): the daemon normalizes raw
+ * doctor probes, auth-source readiness, and the configured-model verdict into
+ * this typed list so every surface (Settings, Onboarding, AuthSheet) renders
+ * the SAME rows — icon from `status`, name from `title`, evidence from
+ * `detail` — and never parses strings or matches id substrings again. Raw
+ * checks/reasons stay on the DTO for "copy raw" evidence.
+ */
+export const ReadinessCheckDto = z
+    .object({
+    id: z.string().describe("Stable machine id of the check (adapter probe id or auth source)."),
+    kind: z
+        .enum(["binary", "auth", "smoke", "model", "probe"])
+        .describe("What KIND of readiness this is: binary presence, credential source, isolated smoke, configured-model validity, or a generic capability probe."),
+    title: z.string().describe("Human display name of the check."),
+    status: z.enum(["pass", "fail", "skip"]).describe("Outcome; skip = not run / not applicable."),
+    detail: z
+        .string()
+        .nullable()
+        .default(null)
+        .describe("Redacted human-readable evidence for the outcome."),
+})
+    .describe("One display-ready readiness check row (daemon-normalized).");
+export const HarnessStatusDto = z
+    .object({
+    id: z.string().describe("Harness id."),
+    status: AdapterStatus,
+    manifest: HarnessManifest.nullable()
+        .optional()
+        .describe("The harness's declared manifest, when available."),
+    enabledIntents: z
+        .array(z.string())
+        .default([])
+        .describe("Intents the gateway will route to this harness."),
+    /** Intents this harness is ACTUALLY routable for right now: enabledIntents
+     * gated by doctor readiness (a degraded/unauth'd harness routes nothing).
+     * The SERVER-side availability truth — surfaces read this field and never
+     * re-derive availability from status+intents business logic (R8). */
+    routableIntents: z
+        .array(z.string())
+        .default([])
+        .describe("Intents the harness is actually routable for right now (doctor-gated); the server-side availability truth surfaces must read instead of re-deriving."),
+    disabledIntents: z.array(z.string()).default([]).describe("Intents the doctor disabled."),
+    checks: z.array(ConformanceCheck).default([]).describe("Doctor probe results."),
+    reasons: z
+        .array(z.string())
+        .default([])
+        .describe("Human-readable reasons for degraded/unavailable status."),
+    authSources: z
+        .array(AuthSourceReadiness)
+        .default([])
+        .describe("Doctor-backed readiness by authentication source; an empty array means readiness was not reported."),
+    /** Daemon-normalized display list (W4.7): what surfaces RENDER. Derived
+     * from checks + authSources + configuredModelCheck by one producer. */
+    readiness: z
+        .array(ReadinessCheckDto)
+        .default([])
+        .describe("Display-ready readiness checks, daemon-normalized from the raw evidence."),
+    /** The user's configured per-harness default model, if any. */
+    configuredModel: z
+        .string()
+        .nullable()
+        .default(null)
+        .describe("The user's configured per-harness default model, if any."),
+    /** Strict truth-source check of `configuredModel`: null when no model
+     * is configured; a rejection carries the actionable message so UIs render
+     * the same honesty `claudexor doctor` prints. */
+    configuredModelCheck: z
+        .object({
+        status: z
+            .enum(["ok", "rejected"])
+            .describe("Whether the configured model passes the strict truth-source check."),
+        message: z
+            .string()
+            .nullable()
+            .default(null)
+            .describe("Actionable rejection message, when rejected."),
+    })
+        .nullable()
+        .default(null)
+        .describe("Strict truth-source check of configuredModel; null when no model is configured."),
+})
+    .describe("Doctor-backed status row for one harness: status, intents, checks, and configured-model validity.");
+//# sourceMappingURL=readiness.js.map

package/dist/readiness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readiness.js","sourceRoot":"","sources":["../src/readiness.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEhD;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC;KAC/B,MAAM,CAAC;IACN,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,mEAAmE,CAAC;IAC5F,IAAI,EAAE,CAAC;SACJ,IAAI,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;SACnD,QAAQ,CACP,+IAA+I,CAChJ;IACH,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,kCAAkC,CAAC;IAC9D,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,2CAA2C,CAAC;IAC9F,MAAM,EAAE,CAAC;SACN,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,OAAO,CAAC,IAAI,CAAC;SACb,QAAQ,CAAC,mDAAmD,CAAC;CACjE,CAAC;KACD,QAAQ,CAAC,4DAA4D,CAAC,CAAC;AAG1E,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC;KAC9B,MAAM,CAAC;IACN,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,aAAa,CAAC;IACtC,MAAM,EAAE,aAAa;IACrB,QAAQ,EAAE,eAAe,CAAC,QAAQ,EAAE;SACjC,QAAQ,EAAE;SACV,QAAQ,CAAC,kDAAkD,CAAC;IAC/D,cAAc,EAAE,CAAC;SACd,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;SACjB,OAAO,CAAC,EAAE,CAAC;SACX,QAAQ,CAAC,iDAAiD,CAAC;IAC9D;;;yEAGqE;IACrE,eAAe,EAAE,CAAC;SACf,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;SACjB,OAAO,CAAC,EAAE,CAAC;SACX,QAAQ,CACP,sJAAsJ,CACvJ;IACH,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,8BAA8B,CAAC;IACzF,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,uBAAuB,CAAC;IAC/E,OAAO,EAAE,CAAC;SACP,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;SACjB,OAAO,CAAC,EAAE,CAAC;SACX,QAAQ,CAAC,yDAAyD,CAAC;IACtE,WAAW,EAAE,CAAC;SACX,KAAK,CAAC,mBAAmB,CAAC;SAC1B,OAAO,CAAC,EAAE,CAAC;SACX,QAAQ,CACP,oGAAoG,CACrG;IACH;2EACuE;IACvE,SAAS,EAAE,CAAC;SACT,KAAK,CAAC,iBAAiB,CAAC;SACxB,OAAO,CAAC,EAAE,CAAC;SACX,QAAQ,CAAC,0EAA0E,CAAC;IACvF,+DAA+D;IAC/D,eAAe,EAAE,CAAC;SACf,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,OAAO,CAAC,IAAI,CAAC;SACb,QAAQ,CAAC,0DAA0D,CAAC;IACvE;;qDAEiD;IACjD,oBAAoB,EAAE,CAAC;SACpB,MAAM,CAAC;QACN,MAAM,EAAE,CAAC;aACN,IAAI,CAAC,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;aACxB,QAAQ,CAAC,oEAAoE,CAAC;QACjF,OAAO,EAAE,CAAC;aACP,MAAM,EAAE;aACR,QAAQ,EAAE;aACV,OAAO,CAAC,IAAI,CAAC;aACb,QAAQ,CAAC,8CAA8C,CAAC;KAC5D,CAAC;SACD,QAAQ,EAAE;SACV,OAAO,CAAC,IAAI,CAAC;SACb,QAAQ,CAAC,iFAAiF,CAAC;CAC/F,CAAC;KACD,QAAQ,CACP,mGAAmG,CACpG,CAAC"}

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