feat(import): carry every field the app's own files write

The JSON import read six measurement fields and six mood fields while
the full backup and the JSON export carry twice that. A sleep night came
back as stageless rows, a range reading as a single value, an ECG alert
without its verdict, and a mood entry without its note, its level-A
values, its zone, its tag and factor links or its day context.

The import now reads valueMin/valueMax, sleepStage,
rhythmClassification and deviceType on a reading, and note, a1 to a5,
tz, factors, structuredTags and context on a mood entry. Each mood entry
is written with its links and context in one transaction, the way the
bulk mood ingest writes one. A link to a tag the importing account does
not have is dropped and named in droppedTagKeys / droppedFactorKeys, and
the import card says which. The schema moves to
src/lib/import/json/schema.ts so the guards can read it.

json-import-field-coverage.test.ts runs the JSON export and both backup
variants on an account with every column filled in: every field they
write is either read by the import or named with the reason it is not
(row ids, source, deletion records, ciphertext, sync bookkeeping), and a
reason for a field no exporter writes fails as stale. The round trip
imports each file into a fresh account and compares the re-export field
for field. The published contract is held to the runtime schema.

src/app/api/import/__tests__/route.test.ts

@@ -8,8 +8,8 @@ vi.mock("@/lib/api-handler", () => ({
   })),
 }));
 
-vi.mock("@/lib/db", () => ({
-  prisma: {
+vi.mock("@/lib/db", () => {
+  const prisma = {
     measurement: {
       create: vi.fn(),
       createManyAndReturn: vi.fn(),
@@ -18,8 +18,13 @@ vi.mock("@/lib/db", () => ({
       upsert: vi.fn(),
     },
     moodEntry: { create: vi.fn(), findUnique: vi.fn(), upsert: vi.fn() },
-  },
-}));
+    // A mood entry is written in a transaction with its links and context;
+    // the callback runs against this same client. Given as the mock's own
+    // implementation, so `resetAllMocks` keeps it.
+    $transaction: vi.fn(async (fn: (tx: unknown) => unknown) => fn(prisma)),
+  };
+  return { prisma };
+});
 
 vi.mock("@/lib/rate-limit", () => ({
   checkRateLimit: vi.fn(),

src/app/api/import/route.ts

@@ -1,7 +1,7 @@
 /**
  * `POST /api/import` — import user data (JSON format matching the export
  * structure). The route authenticates, meters and parses the file; the
- * writers live in `src/lib/import/json/`. The app's own full backup and JSON
+ * schema and the writers live in `src/lib/import/json/`. The app's own full backup and JSON
  * export are read in their own terms first (`normalizeJsonImportFile`).
  */
 import { apiHandler, requireAuth } from "@/lib/api-handler";
@@ -16,94 +16,14 @@ import {
 } from "@/lib/api-response";
 import { checkRateLimit } from "@/lib/rate-limit";
 import { NextRequest } from "next/server";
-import { z } from "zod/v4";
 
-import {
-  validateMeasurementRange,
-  measurementTypeEnum,
-  glucoseContextEnum,
-} from "@/lib/validations/measurement";
-import {
-  isPlausibleEntryInstant,
-  validateEntryInstant,
-} from "@/lib/validations/entry-instant";
-import { isoDateTime } from "@/lib/validations/datetime";
-import { fallbackMoodDateStart } from "@/lib/import/json/mood";
+import { droppedLinkKeysForWire } from "@/lib/mood/tag-links";
 import { normalizeJsonImportFile } from "@/lib/import/json/normalize";
 import { runJsonImport } from "@/lib/import/json/run";
-
-// Derived from canonical enum so round-trip export → import covers every
-// type. Previous hardcoded subset silently dropped 4 of 11 types
-// (V3 audit: enum drift cousins).
-const measurementSchema = z
-  .object({
-    type: measurementTypeEnum,
-    value: z.number(),
-    unit: z.string(),
-    // v1.17.1 — share the canonical entry-instant bound used by the single
-    // POST + edit paths (v1.17 W1b). Previously a bare datetime check
-    // with no ceiling, so a crafted JSON import could forward-date a reading.
-    // `validateEntryInstant` rejects any future instant beyond a 5-min skew
-    // tolerance and any instant before 1900; the field transforms to a `Date`.
-    measuredAt: validateEntryInstant(
-      isoDateTime().transform((s) => new Date(s)),
-    ),
-    glucoseContext: glucoseContextEnum.optional(),
-    source: z.string().optional(),
-    notes: z.string().optional(),
-    // v1.17.1 — optional source-stable id. When present, the import upserts on
-    // `(userId, type, source=IMPORT, externalId)` so a re-import of the same
-    // export is idempotent rather than minting a duplicate set — mirrors the
-    // mood path. Absent → first-write-wins create with a NULL externalId
-    // (distinct in the unique key), which DOES duplicate on re-import.
-    // Stability is enforced per entry in the import loop, not at the
-    // field: a schema-level refusal would fail the whole file on one bad
-    // row.
-    // @external-id-checked-per-entry: src/lib/import/json/measurements.ts
-    externalId: z.string().min(1).max(120).optional(),
-  })
-  .refine(
-    (data) => validateMeasurementRange(data.type, data.value) === null,
-    "Wert ausserhalb des plausiblen Bereichs",
-  );
-
-const moodEntrySchema = z
-  .object({
-    date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
-    mood: z.enum(["SUPER_GUT", "GUT", "OKAY", "SCHLECHT", "LAUSIG"]),
-    score: z.number().int().min(1).max(5),
-    tags: z.string().optional(),
-    // v1.17.1 — same entry-instant bound as measurements; an imported mood
-    // log cannot be forward-dated. Optional + transforms to a `Date` when set.
-    loggedAt: validateEntryInstant(
-      isoDateTime().transform((s) => new Date(s)),
-    ).optional(),
-    // v1.12.1 — optional source-stable id (e.g. a Daylio row id). When
-    // present, the import upserts on `(userId, source, externalId)` so a
-    // re-import of the same export is idempotent rather than minting a
-    // duplicate; absent → the legacy first-write-wins create path.
-    // Stability is enforced per entry in the import loop, not at the
-    // field: a schema-level refusal would fail the whole file on one bad
-    // row.
-    // @external-id-checked-per-entry: src/lib/import/json/mood.ts
-    externalId: z.string().min(1).max(120).optional(),
-  })
-  .superRefine((entry, ctx) => {
-    if (entry.loggedAt) return;
-    const dateStart = fallbackMoodDateStart(entry.date);
-    if (!dateStart || !isPlausibleEntryInstant(dateStart)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["date"],
-        message: "Mood date must be between 1900 and today",
-      });
-    }
-  });
-
-const importSchema = z.object({
-  measurements: z.array(measurementSchema).max(10000).optional(),
-  moodEntries: z.array(moodEntrySchema).max(10000).optional(),
-});
+import {
+  JSON_IMPORT_MAX_BYTES,
+  jsonImportSchema,
+} from "@/lib/import/json/schema";
 
 export const POST = apiHandler(async (request: NextRequest) => {
   const { user } = await requireAuth();
@@ -118,12 +38,12 @@ export const POST = apiHandler(async (request: NextRequest) => {
   }
 
   const { data: body, error: jsonError } = await safeJson(request, {
-    maxBytes: 16 * 1024 * 1024,
+    maxBytes: JSON_IMPORT_MAX_BYTES,
   });
 
   if (jsonError) return jsonError;
   const normalized = normalizeJsonImportFile(body);
-  const parsed = importSchema.safeParse(normalized.file);
+  const parsed = jsonImportSchema.safeParse(normalized.file);
   if (!parsed.success) {
     return apiValidationError(
       parsed.error.issues[0]?.message ?? "Invalid import payload",
@@ -132,13 +52,23 @@ export const POST = apiHandler(async (request: NextRequest) => {
     );
   }
 
-  const { stats: written, writeFailed } = await runJsonImport({
+  const {
+    stats: written,
+    writeFailed,
+    droppedLinkKeys,
+  } = await runJsonImport({
     userId: user.id,
     measurements: parsed.data.measurements,
     moodEntries: parsed.data.moodEntries,
     ipAddress: getClientIp(request),
   });
-  const stats = { ...written, skipped: written.skipped + normalized.skipped };
+  const stats = {
+    ...written,
+    skipped: written.skipped + normalized.skipped,
+    // The mood links the account could not resolve, by key, only when there
+    // are any: "imported" alone told the person their tags had landed.
+    ...droppedLinkKeysForWire(droppedLinkKeys),
+  };
 
   if (writeFailed) {
     return apiError("Import write failed", 503, {