@murphai/contracts 0.1.1

package/dist/zod.js

@@ -0,0 +1,834 @@
+import * as z from "zod";
+import { ADVERSE_EFFECT_SEVERITIES, ALLERGY_CRITICALITIES, ALLERGY_STATUSES, ASSESSMENT_SOURCES, AUDIT_ACTIONS, AUDIT_ACTORS, AUDIT_STATUSES, BLOOD_TEST_FASTING_STATUSES, BLOOD_TEST_RESULT_FLAGS, CONDITION_CLINICAL_STATUSES, CONDITION_SEVERITIES, CONDITION_VERIFICATION_STATUSES, CONTRACT_ID_FORMAT, CONTRACT_SCHEMA_VERSION, ERROR_CODE_VALUES, EVENT_KINDS, EVENT_SOURCES, EXPERIMENT_PHASES, EXPERIMENT_STATUSES, FILE_CHANGE_OPERATIONS, FOOD_STATUSES, FRONTMATTER_DOC_TYPES, GOAL_HORIZONS, GOAL_STATUSES, ID_PREFIXES, PROFILE_SNAPSHOT_SOURCES, RAW_IMPORT_KINDS, RECIPE_STATUSES, PROTOCOL_KINDS, PROTOCOL_STATUSES, WORKOUT_FORMAT_STATUSES, SAMPLE_QUALITIES, SAMPLE_SOURCES, SAMPLE_STREAMS, SLEEP_STAGES, TEST_RESULT_STATUSES, VARIANT_SIGNIFICANCES, VARIANT_ZYGOSITIES, } from "./constants.js";
+import { GENERIC_CONTRACT_ID_PATTERN, idPattern } from "./ids.js";
+import { isStrictIsoDate, isStrictIsoDateTime, isValidIanaTimeZone, } from "./time.js";
+const DAY_KEY_PATTERN = "^\\d{4}-\\d{2}-\\d{2}$";
+const RAW_PATH_PATTERN = "^raw/[A-Za-z0-9._/-]+$";
+const RAW_DOCUMENT_PATH_PATTERN = "^raw/documents/[A-Za-z0-9._/-]+$";
+const RAW_MEAL_PATH_PATTERN = "^raw/meals/[A-Za-z0-9._/-]+$";
+const RAW_ASSESSMENT_SOURCE_PATTERN = "^raw/assessments/[A-Za-z0-9._/-]+/source\\.json$";
+const RELATIVE_PATH_PATTERN = "^(?!/)(?!.*(?:^|/)\\.\\.(?:/|$))[A-Za-z0-9._/-]+$";
+const SHA256_HEX_PATTERN = "^[a-f0-9]{64}$";
+const SLUG_PATTERN = "^[a-z0-9]+(?:-[a-z0-9]+)*$";
+const DAILY_TIME_PATTERN = "^(?:[01]\\d|2[0-3]):[0-5]\\d$";
+const UNIT_PATTERN = "^[A-Za-z0-9._/%-]+$";
+export const FAMILY_MEMBER_LIMITS = Object.freeze({
+    title: 160,
+    relationship: 120,
+    condition: 160,
+    note: 4000,
+});
+export const GENETIC_VARIANT_LIMITS = Object.freeze({
+    title: 160,
+    gene: 40,
+    inheritance: 120,
+    note: 4000,
+});
+function withContractMetadata(schema, id, title) {
+    return schema.meta({
+        $id: id,
+        title,
+    });
+}
+function boundedString(minLength, maxLength) {
+    return z.string().min(minLength).max(maxLength);
+}
+function patternedString(pattern, minLength, maxLength) {
+    let schema = z.string();
+    if (minLength !== undefined) {
+        schema = schema.min(minLength);
+    }
+    if (maxLength !== undefined) {
+        schema = schema.max(maxLength);
+    }
+    return schema.regex(new RegExp(pattern));
+}
+function isoDateTimeString() {
+    return z
+        .string()
+        .meta({ format: "date-time" })
+        .refine((value) => isStrictIsoDateTime(value), "Invalid ISO date-time string.");
+}
+function isoDateString() {
+    return z
+        .string()
+        .meta({ format: "date" })
+        .refine((value) => isStrictIsoDate(value), "Invalid ISO date string.");
+}
+function timeZoneString(options = {}) {
+    const schema = boundedString(3, 64).refine((value) => isValidIanaTimeZone(value), "Invalid IANA time zone.");
+    return options.optional ? schema.optional() : schema;
+}
+function integerSchema(minimum, maximum) {
+    let schema = z.number();
+    if (minimum !== undefined) {
+        schema = schema.min(minimum);
+    }
+    if (maximum !== undefined) {
+        schema = schema.max(maximum);
+    }
+    return schema
+        .meta({ type: "integer" })
+        .refine((value) => Number.isInteger(value), "Expected an integer.");
+}
+function numberSchema(minimum, maximum) {
+    let schema = z.number();
+    if (minimum !== undefined) {
+        schema = schema.min(minimum);
+    }
+    if (maximum !== undefined) {
+        schema = schema.max(maximum);
+    }
+    return schema;
+}
+function uniqueArray(itemSchema, options = {}) {
+    let schema = z.array(itemSchema);
+    if (options.minItems !== undefined) {
+        schema = schema.min(options.minItems);
+    }
+    if (options.maxItems !== undefined) {
+        schema = schema.max(options.maxItems);
+    }
+    if (options.uniqueItems) {
+        schema = schema
+            .meta({ uniqueItems: true })
+            .superRefine((values, context) => {
+            const serialized = values.map((value) => JSON.stringify(value));
+            if (new Set(serialized).size !== serialized.length) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: "Expected unique array items.",
+                });
+            }
+        });
+    }
+    return schema;
+}
+function idSchema(prefix) {
+    return patternedString(idPattern(prefix));
+}
+const jsonValueSchema = z.lazy(() => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(jsonValueSchema),
+    z.object({}).catchall(jsonValueSchema),
+]));
+export const jsonObjectSchema = z.object({}).catchall(jsonValueSchema);
+export const externalRefSchema = z
+    .object({
+    system: patternedString(SLUG_PATTERN),
+    resourceType: patternedString(SLUG_PATTERN),
+    resourceId: boundedString(1, 200),
+    version: boundedString(1, 200).optional(),
+    facet: patternedString(SLUG_PATTERN).optional(),
+})
+    .strict();
+const activityStrengthExerciseBaseShape = {
+    exercise: boundedString(1, 160),
+    setCount: integerSchema(1),
+    repsPerSet: integerSchema(1),
+    loadDescription: boundedString(1, 240).optional(),
+};
+const activityStrengthExerciseWithoutLoadSchema = z
+    .object(activityStrengthExerciseBaseShape)
+    .strict();
+const activityStrengthExerciseWithLoadSchema = z
+    .object({
+    ...activityStrengthExerciseBaseShape,
+    load: numberSchema(0),
+    loadUnit: z.enum(["lb", "kg"]),
+})
+    .strict();
+export const activityStrengthExerciseSchema = z.union([
+    activityStrengthExerciseWithoutLoadSchema,
+    activityStrengthExerciseWithLoadSchema,
+]);
+const bloodTestResultComparatorSchema = z.enum(["<", "<=", ">", ">="]);
+export const bloodTestReferenceRangeSchema = z
+    .object({
+    low: numberSchema().optional(),
+    high: numberSchema().optional(),
+    text: boundedString(1, 160).optional(),
+})
+    .strict()
+    .refine((value) => value.low !== undefined || value.high !== undefined || value.text !== undefined, {
+    message: "Blood-test reference ranges must include at least one boundary or a text range.",
+});
+export const bloodTestResultSchema = z
+    .object({
+    analyte: boundedString(1, 160),
+    slug: patternedString(SLUG_PATTERN).optional(),
+    value: numberSchema().optional(),
+    textValue: boundedString(1, 160).optional(),
+    comparator: bloodTestResultComparatorSchema.optional(),
+    unit: boundedString(1, 64).optional(),
+    flag: z.enum(BLOOD_TEST_RESULT_FLAGS).optional(),
+    biomarkerSlug: patternedString(SLUG_PATTERN).optional(),
+    referenceRange: bloodTestReferenceRangeSchema.optional(),
+    note: boundedString(1, 240).optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.value === undefined && value.textValue === undefined) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Blood-test results require either a numeric value or a textValue.",
+            path: ["value"],
+        });
+    }
+});
+const baseEventShape = {
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.event),
+    id: idSchema(ID_PREFIXES.event),
+    occurredAt: isoDateTimeString(),
+    recordedAt: isoDateTimeString(),
+    dayKey: patternedString(DAY_KEY_PATTERN),
+    source: z.enum(EVENT_SOURCES),
+    title: boundedString(1, 160),
+};
+const eventLifecycleSchema = z
+    .object({
+    revision: integerSchema(1),
+    state: z.enum(["deleted"]).optional(),
+})
+    .strict();
+const baseEventOptionalShape = {
+    tags: uniqueArray(patternedString(SLUG_PATTERN), { uniqueItems: true }).optional(),
+    relatedIds: uniqueArray(patternedString(GENERIC_CONTRACT_ID_PATTERN), { uniqueItems: true }).optional(),
+    rawRefs: uniqueArray(patternedString(RAW_PATH_PATTERN), { uniqueItems: true }).optional(),
+    externalRef: externalRefSchema.optional(),
+    lifecycle: eventLifecycleSchema.optional(),
+    timeZone: timeZoneString({ optional: true }),
+};
+function eventSchema(kind, extraShape) {
+    return z
+        .object({
+        ...baseEventShape,
+        kind: z.literal(kind),
+        note: boundedString(1, 4000).optional(),
+        ...baseEventOptionalShape,
+        ...extraShape,
+    })
+        .strict();
+}
+const baseSampleShape = {
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.sample),
+    id: idSchema(ID_PREFIXES.sample),
+    recordedAt: isoDateTimeString(),
+    dayKey: patternedString(DAY_KEY_PATTERN),
+    source: z.enum(SAMPLE_SOURCES),
+    quality: z.enum(SAMPLE_QUALITIES),
+};
+const baseSampleOptionalShape = {
+    externalRef: externalRefSchema.optional(),
+    timeZone: timeZoneString({ optional: true }),
+};
+function sampleSchema(stream, extraShape) {
+    return z
+        .object({
+        ...baseSampleShape,
+        stream: z.literal(stream),
+        ...baseSampleOptionalShape,
+        ...extraShape,
+    })
+        .strict();
+}
+export const vaultMetadataSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.vault),
+    vaultId: idSchema(ID_PREFIXES.vault),
+    createdAt: isoDateTimeString(),
+    title: boundedString(1, 120),
+    timezone: timeZoneString(),
+    idPolicy: z
+        .object({
+        format: z.literal(CONTRACT_ID_FORMAT),
+        prefixes: z
+            .object({
+            allergy: z.literal(ID_PREFIXES.allergy),
+            assessment: z.literal(ID_PREFIXES.assessment),
+            audit: z.literal(ID_PREFIXES.audit),
+            condition: z.literal(ID_PREFIXES.condition),
+            document: z.literal(ID_PREFIXES.document),
+            event: z.literal(ID_PREFIXES.event),
+            experiment: z.literal(ID_PREFIXES.experiment),
+            family: z.literal(ID_PREFIXES.family),
+            food: z.literal(ID_PREFIXES.food),
+            goal: z.literal(ID_PREFIXES.goal),
+            meal: z.literal(ID_PREFIXES.meal),
+            pack: z.literal(ID_PREFIXES.pack),
+            profileSnapshot: z.literal(ID_PREFIXES.profileSnapshot),
+            provider: z.literal(ID_PREFIXES.provider),
+            recipe: z.literal(ID_PREFIXES.recipe),
+            protocol: z.literal(ID_PREFIXES.protocol),
+            sample: z.literal(ID_PREFIXES.sample),
+            transform: z.literal(ID_PREFIXES.transform),
+            variant: z.literal(ID_PREFIXES.variant),
+            vault: z.literal(ID_PREFIXES.vault),
+            workoutFormat: z.literal(ID_PREFIXES.workoutFormat),
+        })
+            .strict(),
+    })
+        .strict(),
+    paths: z
+        .object({
+        allergiesRoot: z.literal("bank/allergies"),
+        assessmentLedgerRoot: z.literal("ledger/assessments"),
+        conditionsRoot: z.literal("bank/conditions"),
+        coreDocument: z.literal("CORE.md"),
+        familyRoot: z.literal("bank/family"),
+        foodsRoot: z.literal("bank/foods"),
+        geneticsRoot: z.literal("bank/genetics"),
+        goalsRoot: z.literal("bank/goals"),
+        journalRoot: z.literal("journal"),
+        experimentsRoot: z.literal("bank/experiments"),
+        profileCurrentDocument: z.literal("bank/profile/current.md"),
+        profileRoot: z.literal("bank/profile"),
+        profileSnapshotsRoot: z.literal("ledger/profile-snapshots"),
+        providersRoot: z.literal("bank/providers"),
+        recipesRoot: z.literal("bank/recipes"),
+        workoutFormatsRoot: z.literal("bank/workout-formats"),
+        rawAssessmentsRoot: z.literal("raw/assessments"),
+        rawRoot: z.literal("raw"),
+        eventsRoot: z.literal("ledger/events"),
+        protocolsRoot: z.literal("bank/protocols"),
+        samplesRoot: z.literal("ledger/samples"),
+        auditRoot: z.literal("audit"),
+        exportsRoot: z.literal("exports"),
+    })
+        .strict(),
+    shards: z
+        .object({
+        assessments: z.literal("ledger/assessments/YYYY/YYYY-MM.jsonl"),
+        events: z.literal("ledger/events/YYYY/YYYY-MM.jsonl"),
+        profileSnapshots: z.literal("ledger/profile-snapshots/YYYY/YYYY-MM.jsonl"),
+        samples: z.literal("ledger/samples/<stream>/YYYY/YYYY-MM.jsonl"),
+        audit: z.literal("audit/YYYY/YYYY-MM.jsonl"),
+    })
+        .strict(),
+})
+    .strict(), "@murphai/contracts/vault-metadata.schema.json", "Murph Vault Metadata");
+export const eventRecordSchema = withContractMetadata(z.discriminatedUnion("kind", [
+    eventSchema("document", {
+        documentId: idSchema(ID_PREFIXES.document),
+        documentPath: patternedString(RAW_DOCUMENT_PATH_PATTERN),
+        mimeType: boundedString(3, 120),
+        providerId: idSchema(ID_PREFIXES.provider).optional(),
+    }),
+    eventSchema("encounter", {
+        encounterType: boundedString(1, 160),
+        location: boundedString(1, 160).optional(),
+        providerId: idSchema(ID_PREFIXES.provider).optional(),
+    }),
+    eventSchema("meal", {
+        mealId: idSchema(ID_PREFIXES.meal),
+        photoPaths: uniqueArray(patternedString(RAW_MEAL_PATH_PATTERN), { uniqueItems: true }),
+        audioPaths: z.array(patternedString(RAW_MEAL_PATH_PATTERN)),
+        ingredients: uniqueArray(boundedString(1, 4000), { maxItems: 100 }).optional(),
+    }),
+    eventSchema("symptom", {
+        symptom: boundedString(1, 120),
+        intensity: integerSchema(0, 10),
+        bodySite: boundedString(1, 120).optional(),
+    }),
+    z
+        .object({
+        ...baseEventShape,
+        kind: z.literal("note"),
+        ...baseEventOptionalShape,
+        note: boundedString(1, 4000),
+    })
+        .strict(),
+    eventSchema("observation", {
+        metric: patternedString(SLUG_PATTERN),
+        value: numberSchema(),
+        unit: patternedString(UNIT_PATTERN),
+    }),
+    eventSchema("experiment_event", {
+        experimentId: idSchema(ID_PREFIXES.experiment),
+        experimentSlug: patternedString(SLUG_PATTERN),
+        phase: z.enum(EXPERIMENT_PHASES),
+    }),
+    eventSchema("medication_intake", {
+        medicationName: boundedString(1, 160),
+        dose: numberSchema(0),
+        unit: patternedString(UNIT_PATTERN),
+    }),
+    eventSchema("procedure", {
+        procedure: boundedString(1, 160),
+        status: boundedString(1, 64),
+    }),
+    eventSchema("supplement_intake", {
+        supplementName: boundedString(1, 160),
+        dose: numberSchema(0),
+        unit: patternedString(UNIT_PATTERN),
+    }),
+    eventSchema("test", {
+        testName: boundedString(1, 160),
+        resultStatus: z.enum(TEST_RESULT_STATUSES),
+        summary: boundedString(1, 4000).optional(),
+        testCategory: boundedString(1, 64).optional(),
+        specimenType: boundedString(1, 64).optional(),
+        labName: boundedString(1, 160).optional(),
+        labPanelId: boundedString(1, 120).optional(),
+        collectedAt: isoDateTimeString().optional(),
+        reportedAt: isoDateTimeString().optional(),
+        fastingStatus: z.enum(BLOOD_TEST_FASTING_STATUSES).optional(),
+        results: z.array(bloodTestResultSchema).min(1).max(500).optional(),
+    }),
+    eventSchema("activity_session", {
+        activityType: patternedString(SLUG_PATTERN),
+        durationMinutes: integerSchema(1),
+        distanceKm: numberSchema(0).optional(),
+        strengthExercises: z.array(activityStrengthExerciseSchema).min(1).max(50).optional(),
+    }),
+    eventSchema("sleep_session", {
+        startAt: isoDateTimeString(),
+        endAt: isoDateTimeString(),
+        durationMinutes: integerSchema(1),
+    }),
+    eventSchema("intervention_session", {
+        interventionType: patternedString(SLUG_PATTERN),
+        durationMinutes: integerSchema(1).optional(),
+        protocolId: idSchema(ID_PREFIXES.protocol).optional(),
+    }),
+    eventSchema("adverse_effect", {
+        substance: boundedString(1, 160),
+        effect: boundedString(1, 160),
+        severity: z.enum(ADVERSE_EFFECT_SEVERITIES),
+    }),
+    eventSchema("exposure", {
+        exposureType: boundedString(1, 160),
+        substance: boundedString(1, 160),
+        duration: boundedString(1, 120).optional(),
+    }),
+]), "@murphai/contracts/event-record.schema.json", "Murph Event Record");
+export const sampleRecordSchema = withContractMetadata(z.discriminatedUnion("stream", [
+    sampleSchema("heart_rate", {
+        value: integerSchema(0),
+        unit: z.literal("bpm"),
+    }),
+    sampleSchema("hrv", {
+        value: numberSchema(0),
+        unit: z.literal("ms"),
+    }),
+    sampleSchema("steps", {
+        value: integerSchema(0),
+        unit: z.literal("count"),
+    }),
+    sampleSchema("sleep_stage", {
+        stage: z.enum(SLEEP_STAGES),
+        startAt: isoDateTimeString(),
+        endAt: isoDateTimeString(),
+        durationMinutes: integerSchema(1),
+        unit: z.literal("stage"),
+    }),
+    sampleSchema("respiratory_rate", {
+        value: numberSchema(0),
+        unit: z.literal("breaths_per_minute"),
+    }),
+    sampleSchema("temperature", {
+        value: numberSchema(),
+        unit: z.literal("celsius"),
+    }),
+    sampleSchema("glucose", {
+        value: numberSchema(0),
+        unit: z.literal("mg_dL"),
+    }),
+]), "@murphai/contracts/sample-record.schema.json", "Murph Sample Record");
+export const auditRecordSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.audit),
+    id: idSchema(ID_PREFIXES.audit),
+    action: z.enum(AUDIT_ACTIONS),
+    status: z.enum(AUDIT_STATUSES),
+    occurredAt: isoDateTimeString(),
+    actor: z.enum(AUDIT_ACTORS),
+    commandName: boundedString(1, 160),
+    summary: boundedString(1, 4000),
+    targetIds: uniqueArray(patternedString(GENERIC_CONTRACT_ID_PATTERN), { uniqueItems: true }).optional(),
+    errorCode: z.enum(ERROR_CODE_VALUES).optional(),
+    changes: z.array(z
+        .object({
+        path: patternedString(RELATIVE_PATH_PATTERN),
+        op: z.enum(FILE_CHANGE_OPERATIONS),
+    })
+        .strict()),
+})
+    .strict(), "@murphai/contracts/audit-record.schema.json", "Murph Audit Record");
+const INBOX_CAPTURE_ID_PATTERN = "^[A-Za-z0-9][A-Za-z0-9_-]*$";
+const INBOX_ATTACHMENT_ID_PATTERN = "^att_[A-Za-z0-9][A-Za-z0-9_-]*_[0-9]{2}$";
+const INBOX_CAPTURE_ATTACHMENT_KIND_VALUES = ["image", "audio", "video", "document", "other"];
+const HEX_SHA256_PATTERN = "^[a-f0-9]{64}$";
+const inboxCaptureThreadSchema = z
+    .object({
+    id: boundedString(1, 4000),
+    title: boundedString(1, 4000).nullable().optional(),
+    isDirect: z.boolean().nullable(),
+})
+    .strict();
+const inboxCaptureActorSchema = z
+    .object({
+    id: boundedString(1, 255).nullable().optional(),
+    displayName: boundedString(1, 255).nullable().optional(),
+    isSelf: z.boolean(),
+})
+    .strict();
+const inboxCaptureAttachmentSchema = z
+    .object({
+    attachmentId: patternedString(INBOX_ATTACHMENT_ID_PATTERN),
+    ordinal: integerSchema(1),
+    externalId: boundedString(1, 255).nullable().optional(),
+    kind: z.enum(INBOX_CAPTURE_ATTACHMENT_KIND_VALUES),
+    mime: boundedString(1, 255).nullable().optional(),
+    originalPath: z.null().optional(),
+    fileName: boundedString(1, 255).nullable().optional(),
+    byteSize: integerSchema(0).nullable().optional(),
+    storedPath: patternedString(RELATIVE_PATH_PATTERN).nullable().optional(),
+    sha256: patternedString(HEX_SHA256_PATTERN).nullable().optional(),
+})
+    .strict();
+export const inboxCaptureRecordSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.inboxCapture),
+    captureId: patternedString(INBOX_CAPTURE_ID_PATTERN),
+    identityKey: boundedString(1, 1024),
+    eventId: idSchema(ID_PREFIXES.event),
+    auditId: idSchema(ID_PREFIXES.audit),
+    source: boundedString(1, 160),
+    accountId: boundedString(1, 255).nullable().optional(),
+    externalId: boundedString(1, 255),
+    thread: inboxCaptureThreadSchema,
+    actor: inboxCaptureActorSchema,
+    occurredAt: isoDateTimeString(),
+    recordedAt: isoDateTimeString(),
+    receivedAt: isoDateTimeString().nullable().optional(),
+    text: boundedString(1, 4000).nullable().optional(),
+    raw: jsonObjectSchema,
+    sourceDirectory: patternedString(RELATIVE_PATH_PATTERN),
+    envelopePath: patternedString(RELATIVE_PATH_PATTERN),
+    rawRefs: uniqueArray(patternedString(RELATIVE_PATH_PATTERN), { uniqueItems: true }),
+    attachments: z.array(inboxCaptureAttachmentSchema),
+})
+    .strict(), "@murphai/contracts/inbox-capture-record.schema.json", "Murph Inbox Capture Record");
+export const coreFrontmatterSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.coreFrontmatter),
+    docType: z.literal(FRONTMATTER_DOC_TYPES.core),
+    vaultId: idSchema(ID_PREFIXES.vault),
+    title: boundedString(1, 160),
+    timezone: timeZoneString(),
+    updatedAt: isoDateTimeString(),
+    activeExperimentSlugs: uniqueArray(patternedString(SLUG_PATTERN), { uniqueItems: true }).optional(),
+})
+    .strict(), "@murphai/contracts/frontmatter-core.schema.json", "Murph CORE Frontmatter");
+export const journalDayFrontmatterSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.journalDayFrontmatter),
+    docType: z.literal(FRONTMATTER_DOC_TYPES.journalDay),
+    dayKey: patternedString(DAY_KEY_PATTERN),
+    eventIds: uniqueArray(idSchema(ID_PREFIXES.event), { uniqueItems: true }),
+    sampleStreams: uniqueArray(z.enum(SAMPLE_STREAMS), { uniqueItems: true }),
+})
+    .strict(), "@murphai/contracts/frontmatter-journal-day.schema.json", "Murph Journal Day Frontmatter");
+export const experimentFrontmatterSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.experimentFrontmatter),
+    docType: z.literal(FRONTMATTER_DOC_TYPES.experiment),
+    experimentId: idSchema(ID_PREFIXES.experiment),
+    slug: patternedString(SLUG_PATTERN),
+    status: z.enum(EXPERIMENT_STATUSES),
+    title: boundedString(1, 160),
+    startedOn: isoDateString(),
+    endedOn: isoDateString().optional(),
+    hypothesis: boundedString(1, 4000).optional(),
+    tags: uniqueArray(patternedString(SLUG_PATTERN), { uniqueItems: true }).optional(),
+})
+    .strict(), "@murphai/contracts/frontmatter-experiment.schema.json", "Murph Experiment Frontmatter");
+export const providerFrontmatterSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.providerFrontmatter),
+    docType: z.literal(FRONTMATTER_DOC_TYPES.provider),
+    providerId: idSchema(ID_PREFIXES.provider),
+    slug: patternedString(SLUG_PATTERN),
+    title: boundedString(1, 160),
+    status: boundedString(1, 64).optional(),
+    specialty: boundedString(1, 160).optional(),
+    organization: boundedString(1, 160).optional(),
+    location: boundedString(1, 160).optional(),
+    website: boundedString(1, 240).optional(),
+    phone: boundedString(1, 64).optional(),
+    note: boundedString(1, 4000).optional(),
+    aliases: uniqueArray(boundedString(1, 160), { uniqueItems: true }).optional(),
+})
+    .strict(), "@murphai/contracts/frontmatter-provider.schema.json", "Murph Provider Frontmatter");
+export const foodFrontmatterSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.foodFrontmatter),
+    docType: z.literal(FRONTMATTER_DOC_TYPES.food),
+    foodId: idSchema(ID_PREFIXES.food),
+    slug: patternedString(SLUG_PATTERN),
+    title: boundedString(1, 160),
+    status: z.enum(FOOD_STATUSES),
+    summary: boundedString(1, 4000).optional(),
+    kind: boundedString(1, 160).optional(),
+    brand: boundedString(1, 160).optional(),
+    vendor: boundedString(1, 160).optional(),
+    location: boundedString(1, 160).optional(),
+    serving: boundedString(1, 160).optional(),
+    aliases: uniqueArray(boundedString(1, 160), { uniqueItems: true }).optional(),
+    ingredients: uniqueArray(boundedString(1, 4000), { maxItems: 100 }).optional(),
+    tags: uniqueArray(patternedString(SLUG_PATTERN), { uniqueItems: true }).optional(),
+    note: boundedString(1, 4000).optional(),
+    attachedProtocolIds: uniqueArray(idSchema(ID_PREFIXES.protocol), {
+        maxItems: 32,
+        uniqueItems: true,
+    }).optional(),
+    autoLogDaily: z
+        .object({
+        time: patternedString(DAILY_TIME_PATTERN),
+    })
+        .strict()
+        .optional(),
+})
+    .strict(), "@murphai/contracts/frontmatter-food.schema.json", "Murph Food Frontmatter");
+export const recipeFrontmatterSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.recipeFrontmatter),
+    docType: z.literal(FRONTMATTER_DOC_TYPES.recipe),
+    recipeId: idSchema(ID_PREFIXES.recipe),
+    slug: patternedString(SLUG_PATTERN),
+    title: boundedString(1, 160),
+    status: z.enum(RECIPE_STATUSES),
+    summary: boundedString(1, 4000).optional(),
+    cuisine: boundedString(1, 160).optional(),
+    dishType: boundedString(1, 160).optional(),
+    source: boundedString(1, 240).optional(),
+    servings: numberSchema(0).optional(),
+    prepTimeMinutes: integerSchema(0).optional(),
+    cookTimeMinutes: integerSchema(0).optional(),
+    totalTimeMinutes: integerSchema(0).optional(),
+    tags: uniqueArray(patternedString(SLUG_PATTERN), { uniqueItems: true }).optional(),
+    ingredients: uniqueArray(boundedString(1, 4000), { maxItems: 100 }).optional(),
+    steps: uniqueArray(boundedString(1, 4000), { maxItems: 100 }).optional(),
+    relatedGoalIds: uniqueArray(idSchema(ID_PREFIXES.goal), { uniqueItems: true }).optional(),
+    relatedConditionIds: uniqueArray(idSchema(ID_PREFIXES.condition), { uniqueItems: true }).optional(),
+})
+    .strict(), "@murphai/contracts/frontmatter-recipe.schema.json", "Murph Recipe Frontmatter");
+export const workoutFormatFrontmatterSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.workoutFormatFrontmatter),
+    docType: z.literal(FRONTMATTER_DOC_TYPES.workoutFormat),
+    workoutFormatId: idSchema(ID_PREFIXES.workoutFormat),
+    slug: patternedString(SLUG_PATTERN),
+    title: boundedString(1, 160),
+    status: z.enum(WORKOUT_FORMAT_STATUSES),
+    summary: boundedString(1, 4000).optional(),
+    activityType: patternedString(SLUG_PATTERN),
+    durationMinutes: integerSchema(1, 24 * 60).optional(),
+    distanceKm: numberSchema(0, 1_000).optional(),
+    strengthExercises: z.array(activityStrengthExerciseSchema).min(1).max(50).optional(),
+    tags: uniqueArray(patternedString(SLUG_PATTERN), { uniqueItems: true }).optional(),
+    note: boundedString(1, 4000).optional(),
+    templateText: boundedString(1, 4000).optional(),
+})
+    .strict(), "@murphai/contracts/frontmatter-workout-format.schema.json", "Murph Workout Format Frontmatter");
+export const assessmentResponseSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.assessmentResponse),
+    id: idSchema(ID_PREFIXES.assessment),
+    assessmentType: patternedString(SLUG_PATTERN),
+    recordedAt: isoDateTimeString(),
+    source: z.enum(ASSESSMENT_SOURCES),
+    rawPath: patternedString(RAW_ASSESSMENT_SOURCE_PATTERN),
+    title: boundedString(1, 160).optional(),
+    questionnaireSlug: patternedString(SLUG_PATTERN).optional(),
+    responses: jsonObjectSchema,
+    relatedIds: uniqueArray(patternedString(GENERIC_CONTRACT_ID_PATTERN), { uniqueItems: true }).optional(),
+})
+    .strict(), "@murphai/contracts/assessment-response.schema.json", "Murph Assessment Response");
+export const rawImportManifestArtifactSchema = z
+    .object({
+    role: boundedString(1, 160),
+    relativePath: patternedString(RAW_PATH_PATTERN),
+    originalFileName: boundedString(1, 255),
+    mediaType: boundedString(1, 255),
+    byteSize: integerSchema(0),
+    sha256: patternedString(SHA256_HEX_PATTERN, 64, 64),
+})
+    .strict();
+export const rawImportManifestSchema = z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.rawImportManifest),
+    importId: patternedString(GENERIC_CONTRACT_ID_PATTERN),
+    importKind: z.enum(RAW_IMPORT_KINDS),
+    importedAt: isoDateTimeString(),
+    source: boundedString(1, 160).nullable(),
+    rawDirectory: patternedString(RAW_PATH_PATTERN),
+    artifacts: uniqueArray(rawImportManifestArtifactSchema, { uniqueItems: true }),
+    provenance: jsonObjectSchema,
+})
+    .strict();
+export const profileSnapshotNarrativeSchema = z
+    .object({
+    summary: boundedString(1, 4000).optional(),
+    highlights: uniqueArray(boundedString(1, 240), { maxItems: 25, uniqueItems: true }).optional(),
+})
+    .strict();
+export const profileSnapshotGoalsSchema = z
+    .object({
+    topGoalIds: uniqueArray(idSchema(ID_PREFIXES.goal), { uniqueItems: true }).optional(),
+})
+    .strict();
+export const profileSnapshotProfileSchema = z
+    .object({
+    narrative: profileSnapshotNarrativeSchema.optional(),
+    goals: profileSnapshotGoalsSchema.optional(),
+    custom: jsonObjectSchema.optional(),
+})
+    .strict();
+export const profileSnapshotSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.profileSnapshot),
+    id: idSchema(ID_PREFIXES.profileSnapshot),
+    recordedAt: isoDateTimeString(),
+    source: z.enum(PROFILE_SNAPSHOT_SOURCES),
+    sourceAssessmentIds: uniqueArray(idSchema(ID_PREFIXES.assessment), { uniqueItems: true }).optional(),
+    sourceEventIds: uniqueArray(idSchema(ID_PREFIXES.event), { uniqueItems: true }).optional(),
+    profile: profileSnapshotProfileSchema,
+})
+    .strict(), "@murphai/contracts/profile-snapshot.schema.json", "Murph Profile Snapshot");
+export const profileCurrentFrontmatterSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.profileCurrentFrontmatter),
+    docType: z.literal(FRONTMATTER_DOC_TYPES.profileCurrent),
+    snapshotId: idSchema(ID_PREFIXES.profileSnapshot),
+    updatedAt: isoDateTimeString(),
+    sourceAssessmentIds: uniqueArray(idSchema(ID_PREFIXES.assessment), { uniqueItems: true }).optional(),
+    sourceEventIds: uniqueArray(idSchema(ID_PREFIXES.event), { uniqueItems: true }).optional(),
+    topGoalIds: uniqueArray(idSchema(ID_PREFIXES.goal), { uniqueItems: true }).optional(),
+})
+    .strict(), "@murphai/contracts/frontmatter-profile-current.schema.json", "Murph Profile Current Frontmatter");
+export const goalFrontmatterSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.goalFrontmatter),
+    docType: z.literal(FRONTMATTER_DOC_TYPES.goal),
+    goalId: idSchema(ID_PREFIXES.goal),
+    slug: patternedString(SLUG_PATTERN),
+    title: boundedString(1, 160),
+    status: z.enum(GOAL_STATUSES),
+    horizon: z.enum(GOAL_HORIZONS),
+    priority: integerSchema(1, 10),
+    window: z
+        .object({
+        startAt: isoDateString(),
+        targetAt: isoDateString().optional(),
+    })
+        .strict(),
+    parentGoalId: z.union([idSchema(ID_PREFIXES.goal), z.null()]).optional(),
+    relatedGoalIds: uniqueArray(idSchema(ID_PREFIXES.goal), { uniqueItems: true }).optional(),
+    relatedExperimentIds: uniqueArray(idSchema(ID_PREFIXES.experiment), { uniqueItems: true }).optional(),
+    domains: uniqueArray(patternedString(SLUG_PATTERN), { uniqueItems: true }).optional(),
+})
+    .strict(), "@murphai/contracts/frontmatter-goal.schema.json", "Murph Goal Frontmatter");
+export const conditionFrontmatterSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.conditionFrontmatter),
+    docType: z.literal(FRONTMATTER_DOC_TYPES.condition),
+    conditionId: idSchema(ID_PREFIXES.condition),
+    slug: patternedString(SLUG_PATTERN),
+    title: boundedString(1, 160),
+    clinicalStatus: z.enum(CONDITION_CLINICAL_STATUSES),
+    verificationStatus: z.enum(CONDITION_VERIFICATION_STATUSES).optional(),
+    assertedOn: isoDateString().optional(),
+    resolvedOn: isoDateString().optional(),
+    severity: z.enum(CONDITION_SEVERITIES).optional(),
+    bodySites: uniqueArray(boundedString(1, 120), { uniqueItems: true }).optional(),
+    relatedGoalIds: uniqueArray(idSchema(ID_PREFIXES.goal), { uniqueItems: true }).optional(),
+    relatedProtocolIds: uniqueArray(idSchema(ID_PREFIXES.protocol), { uniqueItems: true }).optional(),
+    note: boundedString(1, 4000).optional(),
+})
+    .strict(), "@murphai/contracts/frontmatter-condition.schema.json", "Murph Condition Frontmatter");
+export const allergyFrontmatterSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.allergyFrontmatter),
+    docType: z.literal(FRONTMATTER_DOC_TYPES.allergy),
+    allergyId: idSchema(ID_PREFIXES.allergy),
+    slug: patternedString(SLUG_PATTERN),
+    title: boundedString(1, 160),
+    substance: boundedString(1, 160),
+    status: z.enum(ALLERGY_STATUSES),
+    criticality: z.enum(ALLERGY_CRITICALITIES).optional(),
+    reaction: boundedString(1, 160).optional(),
+    recordedOn: isoDateString().optional(),
+    relatedConditionIds: uniqueArray(idSchema(ID_PREFIXES.condition), { uniqueItems: true }).optional(),
+    note: boundedString(1, 4000).optional(),
+})
+    .strict(), "@murphai/contracts/frontmatter-allergy.schema.json", "Murph Allergy Frontmatter");
+export const protocolFrontmatterSchema = withContractMetadata((() => {
+    const supplementIngredientSchema = z
+        .object({
+        compound: boundedString(1, 160),
+        label: boundedString(1, 160).optional(),
+        amount: numberSchema(0).optional(),
+        unit: patternedString(UNIT_PATTERN).optional(),
+        active: z.boolean().optional(),
+        note: boundedString(1, 4000).optional(),
+    })
+        .strict();
+    return z
+        .object({
+        schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.protocolFrontmatter),
+        docType: z.literal(FRONTMATTER_DOC_TYPES.protocol),
+        protocolId: idSchema(ID_PREFIXES.protocol),
+        slug: patternedString(SLUG_PATTERN),
+        title: boundedString(1, 160),
+        kind: z.enum(PROTOCOL_KINDS),
+        status: z.enum(PROTOCOL_STATUSES),
+        startedOn: isoDateString(),
+        stoppedOn: isoDateString().optional(),
+        substance: boundedString(1, 160).optional(),
+        dose: numberSchema(0).optional(),
+        unit: patternedString(UNIT_PATTERN).optional(),
+        schedule: boundedString(1, 160).optional(),
+        brand: boundedString(1, 160).optional(),
+        manufacturer: boundedString(1, 160).optional(),
+        servingSize: boundedString(1, 160).optional(),
+        ingredients: z.array(supplementIngredientSchema).optional(),
+        relatedGoalIds: uniqueArray(idSchema(ID_PREFIXES.goal), { uniqueItems: true }).optional(),
+        relatedConditionIds: uniqueArray(idSchema(ID_PREFIXES.condition), { uniqueItems: true }).optional(),
+    })
+        .strict();
+})(), "@murphai/contracts/frontmatter-protocol.schema.json", "Murph Protocol Frontmatter");
+export const familyMemberFrontmatterSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.familyMemberFrontmatter),
+    docType: z.literal(FRONTMATTER_DOC_TYPES.familyMember),
+    familyMemberId: idSchema(ID_PREFIXES.family),
+    slug: patternedString(SLUG_PATTERN),
+    title: boundedString(1, FAMILY_MEMBER_LIMITS.title),
+    relationship: boundedString(1, FAMILY_MEMBER_LIMITS.relationship),
+    conditions: uniqueArray(boundedString(1, FAMILY_MEMBER_LIMITS.condition), { uniqueItems: true }).optional(),
+    deceased: z.boolean().optional(),
+    note: boundedString(1, FAMILY_MEMBER_LIMITS.note).optional(),
+    relatedVariantIds: uniqueArray(idSchema(ID_PREFIXES.variant), { uniqueItems: true }).optional(),
+})
+    .strict(), "@murphai/contracts/frontmatter-family-member.schema.json", "Murph Family Member Frontmatter");
+export const geneticVariantFrontmatterSchema = withContractMetadata(z
+    .object({
+    schemaVersion: z.literal(CONTRACT_SCHEMA_VERSION.geneticVariantFrontmatter),
+    docType: z.literal(FRONTMATTER_DOC_TYPES.geneticVariant),
+    variantId: idSchema(ID_PREFIXES.variant),
+    slug: patternedString(SLUG_PATTERN),
+    title: boundedString(1, GENETIC_VARIANT_LIMITS.title),
+    gene: boundedString(1, GENETIC_VARIANT_LIMITS.gene),
+    zygosity: z.enum(VARIANT_ZYGOSITIES).optional(),
+    significance: z.enum(VARIANT_SIGNIFICANCES).optional(),
+    inheritance: boundedString(1, GENETIC_VARIANT_LIMITS.inheritance).optional(),
+    sourceFamilyMemberIds: uniqueArray(idSchema(ID_PREFIXES.family), { uniqueItems: true }).optional(),
+    note: boundedString(1, GENETIC_VARIANT_LIMITS.note).optional(),
+})
+    .strict(), "@murphai/contracts/frontmatter-genetic-variant.schema.json", "Murph Genetic Variant Frontmatter");
+//# sourceMappingURL=zod.js.map