V1.1

app/api/ingest/event/route.ts

@@ -1,5 +1,22 @@
 import { NextResponse } from "next/server";
 import { prisma } from "@/lib/prisma";
+import { normalizeEventV1 } from "@/lib/contracts/v1";
+
+function getClientIp(req: Request) {
+  const xf = req.headers.get("x-forwarded-for");
+  if (xf) return xf.split(",")[0]?.trim() || null;
+  return req.headers.get("x-real-ip") || null;
+}
+
+function parseSeqToBigInt(seq: unknown): bigint | null {
+  if (seq === null || seq === undefined) return null;
+  if (typeof seq === "number") {
+    if (!Number.isInteger(seq) || seq < 0) return null;
+    return BigInt(seq);
+  }
+  if (typeof seq === "string" && /^\d+$/.test(seq)) return BigInt(seq);
+  return null;
+}
 
 const normalizeType = (t: any) =>
   String(t ?? "")
@@ -38,57 +55,124 @@ const MICROSTOP_SEC = 60;
 const MACROSTOP_SEC = 300;
 
 export async function POST(req: Request) {
-  const apiKey = req.headers.get("x-api-key");
-  if (!apiKey) {
-    return NextResponse.json({ ok: false, error: "Missing api key" }, { status: 401 });
-  }
+  const endpoint = "/api/ingest/event";
+  const ip = getClientIp(req);
+  const userAgent = req.headers.get("user-agent");
 
-  const body = await req.json().catch(() => null);
-  if (!body?.machineId || !body?.event) {
-    return NextResponse.json({ ok: false, error: "Invalid payload" }, { status: 400 });
-  }
-  
+  let rawBody: any = null;
+  let orgId: string | null = null;
+  let machineId: string | null = null;
+  let schemaVersion: string | null = null;
+  let seq: bigint | null = null;
+  let tsDeviceDate: Date | null = null;
 
-  const machine = await prisma.machine.findFirst({
-    where: { id: String(body.machineId), apiKey },
-    select: { id: true, orgId: true },
-  });
-  if (!machine) {
-    return NextResponse.json({ ok: false, error: "Unauthorized" }, { status: 401 });
-  }
-
-  // Normalize to array (Node-RED sends array of anomalies)
-  const rawEvent = body.event;
-  const events = Array.isArray(rawEvent) ? rawEvent : [rawEvent];
-
-  const created: { id: string; ts: Date; eventType: string }[] = [];
-  const skipped: any[] = [];
-
-  for (const ev of events) {
-    if (!ev || typeof ev !== "object") {
-      skipped.push({ reason: "invalid_event_object" });
-      continue;
+  try {
+    // 1) Auth header exists
+    const apiKey = req.headers.get("x-api-key");
+    if (!apiKey) {
+      await prisma.ingestLog.create({
+        data: {
+          endpoint,
+          ok: false,
+          status: 401,
+          errorCode: "MISSING_API_KEY",
+          errorMsg: "Missing api key",
+          ip,
+          userAgent,
+        },
+      });
+      return NextResponse.json({ ok: false, error: "Missing api key" }, { status: 401 });
     }
 
-    const rawType = (ev as any).eventType ?? (ev as any).anomaly_type ?? (ev as any).topic ?? body.topic ?? "";
+    // 2) Parse JSON
+    rawBody = await req.json().catch(() => null);
+
+    // 3) Reject arrays at the contract boundary (Phase 0 rule)
+    // Edge MUST split arrays into one event per POST.
+    if (rawBody?.event && Array.isArray(rawBody.event)) {
+      await prisma.ingestLog.create({
+        data: {
+          endpoint,
+          ok: false,
+          status: 400,
+          errorCode: "EVENT_ARRAY_NOT_ALLOWED",
+          errorMsg: "Edge must split arrays; send one event per request.",
+          body: rawBody,
+          machineId: rawBody?.machineId ? String(rawBody.machineId) : null,
+          ip,
+          userAgent,
+        },
+      });
+      return NextResponse.json(
+        { ok: false, error: "Invalid payload", detail: "event array not allowed; split on edge" },
+        { status: 400 }
+      );
+    }
+
+    // 4) Normalize to v1 (legacy tolerated)
+    const normalized = normalizeEventV1(rawBody);
+    if (!normalized.ok) {
+      await prisma.ingestLog.create({
+        data: {
+          endpoint,
+          ok: false,
+          status: 400,
+          errorCode: "INVALID_PAYLOAD",
+          errorMsg: normalized.error,
+          body: rawBody,
+          ip,
+          userAgent,
+        },
+      });
+      return NextResponse.json({ ok: false, error: "Invalid payload", detail: normalized.error }, { status: 400 });
+    }
+
+    const body = normalized.value;
+
+    schemaVersion = body.schemaVersion;
+    machineId = body.machineId;
+    seq = parseSeqToBigInt(body.seq);
+    tsDeviceDate = new Date(body.tsDevice);
+
+    // 5) Authorize machineId + apiKey
+    const machine = await prisma.machine.findFirst({
+      where: { id: machineId, apiKey },
+      select: { id: true, orgId: true },
+    });
+
+    if (!machine) {
+      await prisma.ingestLog.create({
+        data: {
+          endpoint,
+          ok: false,
+          status: 401,
+          errorCode: "UNAUTHORIZED",
+          errorMsg: "Unauthorized (machineId/apiKey mismatch)",
+          body: rawBody,
+          machineId,
+          schemaVersion,
+          seq,
+          tsDevice: tsDeviceDate,
+          ip,
+          userAgent,
+        },
+      });
+      return NextResponse.json({ ok: false, error: "Unauthorized" }, { status: 401 });
+    }
+
+    orgId = machine.orgId;
+
+    // 6) Canonicalize + classify type (keep for now; later move to edge in A1)
+    const ev = body.event;
+
+    const rawType =
+      (ev as any).eventType ?? (ev as any).anomaly_type ?? (ev as any).topic ?? (body as any).topic ?? "";
     const typ0 = normalizeType(rawType);
     const typ = CANON_TYPE[typ0] ?? typ0;
 
-    // Determine timestamp
-    const tsMs =
-      (typeof (ev as any)?.timestamp === "number" && (ev as any).timestamp) ||
-      (typeof (ev as any)?.data?.timestamp === "number" && (ev as any).data.timestamp) ||
-      (typeof (ev as any)?.data?.event_timestamp === "number" && (ev as any).data.event_timestamp) ||
-      null;
-
-    const ts = tsMs ? new Date(tsMs) : new Date();
-
-    // Severity defaulting (do not skip on severity — store for audit)
-    let sev = String((ev as any).severity ?? "").trim().toLowerCase();
-    if (!sev) sev = "warning";
+    let finalType = typ;
 
     // Stop classification -> microstop/macrostop
-    let finalType = typ;
     if (typ === "stop") {
       const stopSec =
         (typeof (ev as any)?.data?.stoppage_duration_seconds === "number" && (ev as any).data.stoppage_duration_seconds) ||
@@ -98,36 +182,85 @@ export async function POST(req: Request) {
       if (stopSec != null) {
         finalType = stopSec >= MACROSTOP_SEC ? "macrostop" : "microstop";
       } else {
-        // missing duration -> conservative
         finalType = "microstop";
       }
     }
 
     if (!ALLOWED_TYPES.has(finalType)) {
-      skipped.push({ reason: "type_not_allowed", typ: finalType, sev });
-      continue;
+      await prisma.ingestLog.create({
+        data: {
+          orgId,
+          machineId: machine.id,
+          endpoint,
+          ok: false,
+          status: 400,
+          errorCode: "TYPE_NOT_ALLOWED",
+          errorMsg: `Event type not allowed: ${finalType}`,
+          schemaVersion,
+          seq,
+          tsDevice: tsDeviceDate,
+          body: rawBody,
+          ip,
+          userAgent,
+        },
+      });
+      return NextResponse.json(
+        { ok: false, error: "Invalid event type", detail: finalType },
+        { status: 400 }
+      );
     }
 
+    // Determine severity
+    let sev = String((ev as any).severity ?? "").trim().toLowerCase();
+    if (!sev) sev = "warning";
+
     const title =
       String((ev as any).title ?? "").trim() ||
-      (finalType === "slow-cycle" ? "Slow Cycle Detected" :
-       finalType === "macrostop" ? "Macrostop Detected" :
-       finalType === "microstop" ? "Microstop Detected" :
-       "Event");
+      (finalType === "slow-cycle"
+        ? "Slow Cycle Detected"
+        : finalType === "macrostop"
+        ? "Macrostop Detected"
+        : finalType === "microstop"
+        ? "Microstop Detected"
+        : "Event");
 
     const description = (ev as any).description ? String((ev as any).description) : null;
 
-    // store full blob, ensure object
+    // store full blob
     const rawData = (ev as any).data ?? ev;
-    const dataObj = typeof rawData === "string" ? (() => {
-      try { return JSON.parse(rawData); } catch { return { raw: rawData }; }
-    })() : rawData;
+    const dataObj =
+      typeof rawData === "string"
+        ? (() => {
+            try {
+              return JSON.parse(rawData);
+            } catch {
+              return { raw: rawData };
+            }
+          })()
+        : rawData;
 
+    // Prefer work_order_id always
+    const workOrderId =
+      (ev as any)?.work_order_id ? String((ev as any).work_order_id)
+      : (ev as any)?.data?.work_order_id ? String((ev as any).data.work_order_id)
+      : null;
+
+    const sku =
+      (ev as any)?.sku ? String((ev as any).sku)
+      : (ev as any)?.data?.sku ? String((ev as any).data.sku)
+      : null;
+
+    // 7) Store event with Phase 0 meta
     const row = await prisma.machineEvent.create({
       data: {
-        orgId: machine.orgId,
+        orgId,
         machineId: machine.id,
-        ts,
+
+        // Phase 0 meta
+        schemaVersion,
+        seq,
+        ts: tsDeviceDate,
+
         topic: String((ev as any).topic ?? finalType),
         eventType: finalType,
         severity: sev,
@@ -135,19 +268,69 @@ export async function POST(req: Request) {
         title,
         description,
         data: dataObj,
-        workOrderId:
-          (ev as any)?.work_order_id ? String((ev as any).work_order_id)
-          : (ev as any)?.data?.work_order_id ? String((ev as any).data.work_order_id)
-          : null,
-        sku:
-          (ev as any)?.sku ? String((ev as any).sku)
-          : (ev as any)?.data?.sku ? String((ev as any).data.sku)
-          : null,
+        workOrderId,
+        sku,
       },
     });
 
-    created.push({ id: row.id, ts: row.ts, eventType: row.eventType });
-  }
+    // Optional: update machine last seen
+    await prisma.machine.update({
+      where: { id: machine.id },
+      data: {
+        schemaVersion,
+        seq,
+        tsDevice: tsDeviceDate,
+        tsServer: new Date(),
+      },
+    });
 
-  return NextResponse.json({ ok: true, createdCount: created.length, created, skippedCount: skipped.length, skipped });
+    // 8) Ingest log success
+    await prisma.ingestLog.create({
+      data: {
+        orgId,
+        machineId: machine.id,
+        endpoint,
+        ok: true,
+        status: 200,
+        schemaVersion,
+        seq,
+        tsDevice: tsDeviceDate,
+        body: rawBody,
+        ip,
+        userAgent,
+      },
+    });
+
+    return NextResponse.json({
+      ok: true,
+      createdCount: 1,
+      created: [{ id: row.id, ts: row.ts, eventType: row.eventType }],
+      skippedCount: 0,
+      skipped: [],
+    });
+  } catch (err: any) {
+    const msg = err?.message ? String(err.message) : "Unknown error";
+
+    try {
+      await prisma.ingestLog.create({
+        data: {
+          orgId,
+          machineId,
+          endpoint,
+          ok: false,
+          status: 500,
+          errorCode: "SERVER_ERROR",
+          errorMsg: msg,
+          schemaVersion,
+          seq,
+          tsDevice: tsDeviceDate ?? undefined,
+          body: rawBody,
+          ip,
+          userAgent,
+        },
+      });
+    } catch {}
+
+    return NextResponse.json({ ok: false, error: "Server error", detail: msg }, { status: 500 });
+  }
 }

app/api/ingest/heartbeat/route.ts

@@ -1,32 +1,168 @@
 import { NextResponse } from "next/server";
 import { prisma } from "@/lib/prisma";
+import { normalizeHeartbeatV1 } from "@/lib/contracts/v1";
+
+function getClientIp(req: Request) {
+  const xf = req.headers.get("x-forwarded-for");
+  if (xf) return xf.split(",")[0]?.trim() || null;
+  return req.headers.get("x-real-ip") || null;
+}
+
+function parseSeqToBigInt(seq: unknown): bigint | null {
+  if (seq === null || seq === undefined) return null;
+  if (typeof seq === "number") {
+    if (!Number.isInteger(seq) || seq < 0) return null;
+    return BigInt(seq);
+  }
+  if (typeof seq === "string" && /^\d+$/.test(seq)) return BigInt(seq);
+  return null;
+}
 
 export async function POST(req: Request) {
-  const apiKey = req.headers.get("x-api-key");
-  if (!apiKey) return NextResponse.json({ ok: false, error: "Missing api key" }, { status: 401 });
+  const endpoint = "/api/ingest/heartbeat";
+  const ip = getClientIp(req);
+  const userAgent = req.headers.get("user-agent");
 
-  const body = await req.json().catch(() => null);
-  if (!body?.machineId || !body?.status) {
-    return NextResponse.json({ ok: false, error: "Invalid payload" }, { status: 400 });
+  let rawBody: any = null;
+  let orgId: string | null = null;
+  let machineId: string | null = null;
+  let seq: bigint | null = null;
+  let schemaVersion: string | null = null;
+  let tsDeviceDate: Date | null = null;
+
+  try {
+    // 1) Auth header exists
+    const apiKey = req.headers.get("x-api-key");
+    if (!apiKey) {
+      await prisma.ingestLog.create({
+        data: { endpoint, ok: false, status: 401, errorCode: "MISSING_API_KEY", errorMsg: "Missing api key", ip, userAgent },
+      });
+      return NextResponse.json({ ok: false, error: "Missing api key" }, { status: 401 });
+    }
+
+    // 2) Parse JSON
+    rawBody = await req.json().catch(() => null);
+
+    // 3) Normalize to v1 (legacy tolerated)
+    const normalized = normalizeHeartbeatV1(rawBody);
+    if (!normalized.ok) {
+      await prisma.ingestLog.create({
+        data: { endpoint, ok: false, status: 400, errorCode: "INVALID_PAYLOAD", errorMsg: normalized.error, body: rawBody, ip, userAgent },
+      });
+      return NextResponse.json({ ok: false, error: "Invalid payload", detail: normalized.error }, { status: 400 });
+    }
+
+    const body = normalized.value;
+    schemaVersion = body.schemaVersion;
+    machineId = body.machineId;
+    seq = parseSeqToBigInt(body.seq);
+    tsDeviceDate = new Date(body.tsDevice);
+
+    // 4) Authorize machineId + apiKey
+    const machine = await prisma.machine.findFirst({
+      where: { id: machineId, apiKey },
+      select: { id: true, orgId: true },
+    });
+
+    if (!machine) {
+      await prisma.ingestLog.create({
+        data: {
+          endpoint,
+          ok: false,
+          status: 401,
+          errorCode: "UNAUTHORIZED",
+          errorMsg: "Unauthorized (machineId/apiKey mismatch)",
+          body: rawBody,
+          machineId,
+          schemaVersion,
+          seq,
+          tsDevice: tsDeviceDate,
+          ip,
+          userAgent,
+        },
+      });
+      return NextResponse.json({ ok: false, error: "Unauthorized" }, { status: 401 });
+    }
+
+    orgId = machine.orgId;
+
+    // 5) Store heartbeat
+    // Keep your legacy fields, but store meta fields too.
+    const hb = await prisma.machineHeartbeat.create({
+      data: {
+        orgId,
+        machineId: machine.id,
+
+        // Phase 0 meta
+        schemaVersion,
+        seq,
+        ts: tsDeviceDate,
+
+        // Legacy payload compatibility
+        status: body.status ? String(body.status) : (body.online ? "RUN" : "STOP"),
+        message: body.message ? String(body.message) : null,
+        ip: body.ip ? String(body.ip) : null,
+        fwVersion: body.fwVersion ? String(body.fwVersion) : null,
+      },
+    });
+
+    // Optional: update machine last seen (same as KPI)
+    await prisma.machine.update({
+      where: { id: machine.id },
+      data: {
+        schemaVersion,
+        seq,
+        tsDevice: tsDeviceDate,
+        tsServer: new Date(),
+      },
+    });
+
+    // 6) Ingest log success
+    await prisma.ingestLog.create({
+      data: {
+        orgId,
+        machineId: machine.id,
+        endpoint,
+        ok: true,
+        status: 200,
+        schemaVersion,
+        seq,
+        tsDevice: tsDeviceDate,
+        body: rawBody,
+        ip,
+        userAgent,
+      },
+    });
+
+    return NextResponse.json({
+      ok: true,
+      id: hb.id,
+      tsDevice: hb.ts,
+      tsServer: hb.tsServer,
+    });
+  } catch (err: any) {
+    const msg = err?.message ? String(err.message) : "Unknown error";
+
+    try {
+      await prisma.ingestLog.create({
+        data: {
+          orgId,
+          machineId,
+          endpoint,
+          ok: false,
+          status: 500,
+          errorCode: "SERVER_ERROR",
+          errorMsg: msg,
+          schemaVersion,
+          seq,
+          tsDevice: tsDeviceDate ?? undefined,
+          body: rawBody,
+          ip,
+          userAgent,
+        },
+      });
+    } catch {}
+
+    return NextResponse.json({ ok: false, error: "Server error", detail: msg }, { status: 500 });
   }
-
-  const machine = await prisma.machine.findFirst({
-    where: { id: String(body.machineId), apiKey },
-    select: { id: true, orgId: true },
-  });
-
-  if (!machine) return NextResponse.json({ ok: false, error: "Unauthorized" }, { status: 401 });
-
-  const hb = await prisma.machineHeartbeat.create({
-    data: {
-      orgId: machine.orgId,
-      machineId: machine.id,
-      status: String(body.status),
-      message: body.message ? String(body.message) : null,
-      ip: body.ip ? String(body.ip) : null,
-      fwVersion: body.fwVersion ? String(body.fwVersion) : null,
-    },
-  });
-
-  return NextResponse.json({ ok: true, id: hb.id, ts: hb.ts });
 }

app/api/ingest/kpi/route.ts

@@ -1,50 +1,217 @@
+// mis-control-tower/app/api/ingest/kpi/route.ts
 import { NextResponse } from "next/server";
 import { prisma } from "@/lib/prisma";
+import { normalizeSnapshotV1 } from "@/lib/contracts/v1";
+
+function getClientIp(req: Request) {
+  const xf = req.headers.get("x-forwarded-for");
+  if (xf) return xf.split(",")[0]?.trim() || null;
+  return req.headers.get("x-real-ip") || null;
+}
+
+function parseSeqToBigInt(seq: unknown): bigint | null {
+  if (seq === null || seq === undefined) return null;
+  if (typeof seq === "number") {
+    if (!Number.isInteger(seq) || seq < 0) return null;
+    return BigInt(seq);
+  }
+  if (typeof seq === "string" && /^\d+$/.test(seq)) return BigInt(seq);
+  return null;
+}
 
 export async function POST(req: Request) {
-  const apiKey = req.headers.get("x-api-key");
-  if (!apiKey) return NextResponse.json({ ok: false, error: "Missing api key" }, { status: 401 });
+  const endpoint = "/api/ingest/kpi";
+  const startedAt = Date.now();
+  const ip = getClientIp(req);
+  const userAgent = req.headers.get("user-agent");
 
-  const body = await req.json().catch(() => null);
-  if (!body?.machineId || !body?.kpis) {
-    return NextResponse.json({ ok: false, error: "Invalid payload" }, { status: 400 });
+  let rawBody: any = null;
+  let orgId: string | null = null;
+  let machineId: string | null = null;
+  let seq: bigint | null = null;
+  let schemaVersion: string | null = null;
+  let tsDeviceDate: Date | null = null;
+
+  try {
+    const apiKey = req.headers.get("x-api-key");
+    if (!apiKey) {
+      await prisma.ingestLog.create({
+        data: {
+          endpoint,
+          ok: false,
+          status: 401,
+          errorCode: "MISSING_API_KEY",
+          errorMsg: "Missing api key",
+          ip,
+          userAgent,
+        },
+      });
+      return NextResponse.json({ ok: false, error: "Missing api key" }, { status: 401 });
+    }
+
+    rawBody = await req.json().catch(() => null);
+    const normalized = normalizeSnapshotV1(rawBody);
+    if (!normalized.ok) {
+      await prisma.ingestLog.create({
+        data: {
+          endpoint,
+          ok: false,
+          status: 400,
+          errorCode: "INVALID_PAYLOAD",
+          errorMsg: normalized.error,
+          body: rawBody,
+          ip,
+          userAgent,
+        },
+      });
+      return NextResponse.json({ ok: false, error: "Invalid payload", detail: normalized.error }, { status: 400 });
+    }
+
+    const body = normalized.value;
+
+    schemaVersion = body.schemaVersion;
+    machineId = body.machineId;
+    seq = parseSeqToBigInt(body.seq);
+    tsDeviceDate = new Date(body.tsDevice);
+
+    // Auth: machineId + apiKey must match
+    const machine = await prisma.machine.findFirst({
+      where: { id: machineId, apiKey },
+      select: { id: true, orgId: true },
+    });
+
+    if (!machine) {
+      await prisma.ingestLog.create({
+        data: {
+          endpoint,
+          ok: false,
+          status: 401,
+          errorCode: "UNAUTHORIZED",
+          errorMsg: "Unauthorized (machineId/apiKey mismatch)",
+          body: rawBody,
+          machineId,
+          schemaVersion,
+          seq,
+          tsDevice: tsDeviceDate,
+          ip,
+          userAgent,
+        },
+      });
+      return NextResponse.json({ ok: false, error: "Unauthorized" }, { status: 401 });
+    }
+
+    orgId = machine.orgId;
+
+    const wo = body.activeWorkOrder ?? {};
+    const k = body.kpis ?? {};
+    const safeCycleTime =
+    typeof body.cycleTime === "number" && body.cycleTime > 0
+      ? body.cycleTime
+      : (typeof (wo as any).cycleTime === "number" && (wo as any).cycleTime > 0 ? (wo as any).cycleTime : null);
+
+  const safeCavities =
+    typeof body.cavities === "number" && body.cavities > 0
+      ? body.cavities
+      : (typeof (wo as any).cavities === "number" && (wo as any).cavities > 0 ? (wo as any).cavities : null);
+    // Write snapshot (ts = tsDevice; tsServer auto)
+    const row = await prisma.machineKpiSnapshot.create({
+      data: {
+        orgId,
+        machineId: machine.id,
+
+        // Phase 0 meta
+        schemaVersion,
+        seq,
+        ts: tsDeviceDate, // store device-time in ts; server-time goes to ts_server
+
+        // Work order fields
+        workOrderId: wo.id ? String(wo.id) : null,
+        sku: wo.sku ? String(wo.sku) : null,
+        target: typeof wo.target === "number" ? Math.trunc(wo.target) : null,
+        good: typeof wo.good === "number" ? Math.trunc(wo.good) : null,
+        scrap: typeof wo.scrap === "number" ? Math.trunc(wo.scrap) : null,
+
+        // Counters
+        cycleCount: typeof body.cycle_count === "number" ? body.cycle_count : null,
+        goodParts: typeof body.good_parts === "number" ? body.good_parts : null,
+        scrapParts: typeof body.scrap_parts === "number" ? body.scrap_parts : null,
+        cavities: safeCavities,
+
+        // Cycle times
+        cycleTime: safeCycleTime,
+        actualCycle: typeof body.actualCycleTime === "number" ? body.actualCycleTime : null,
+
+        // KPIs (0..100)
+        availability: typeof k.availability === "number" ? k.availability : null,
+        performance: typeof k.performance === "number" ? k.performance : null,
+        quality: typeof k.quality === "number" ? k.quality : null,
+        oee: typeof k.oee === "number" ? k.oee : null,
+
+        trackingEnabled: typeof body.trackingEnabled === "boolean" ? body.trackingEnabled : null,
+        productionStarted: typeof body.productionStarted === "boolean" ? body.productionStarted : null,
+      },
+    });
+
+    // Optional but useful: update machine "last seen" meta fields
+    await prisma.machine.update({
+      where: { id: machine.id },
+      data: {
+        schemaVersion,
+        seq,
+        tsDevice: tsDeviceDate,
+        tsServer: new Date(),
+      },
+    });
+
+    await prisma.ingestLog.create({
+      data: {
+        orgId,
+        machineId: machine.id,
+        endpoint,
+        ok: true,
+        status: 200,
+        schemaVersion,
+        seq,
+        tsDevice: tsDeviceDate,
+        body: rawBody,
+        ip,
+        userAgent,
+      },
+    });
+
+    return NextResponse.json({
+      ok: true,
+      id: row.id,
+      tsDevice: row.ts,
+      tsServer: row.tsServer,
+    });
+  } catch (err: any) {
+    const msg = err?.message ? String(err.message) : "Unknown error";
+
+    // Never fail the request because logging failed
+    try {
+      await prisma.ingestLog.create({
+        data: {
+          orgId,
+          machineId,
+          endpoint,
+          ok: false,
+          status: 500,
+          errorCode: "SERVER_ERROR",
+          errorMsg: msg,
+          schemaVersion,
+          seq,
+          tsDevice: tsDeviceDate ?? undefined,
+          body: rawBody,
+          ip,
+          userAgent,
+        },
+      });
+    } catch {}
+
+    return NextResponse.json({ ok: false, error: "Server error", detail: msg }, { status: 500 });
+  } finally {
+    // (If later you add latency_ms to IngestLog, you can store Date.now() - startedAt here.)
+    void startedAt;
   }
-
-  const machine = await prisma.machine.findFirst({
-    where: { id: String(body.machineId), apiKey },
-    select: { id: true, orgId: true },
-  });
-  if (!machine) return NextResponse.json({ ok: false, error: "Unauthorized" }, { status: 401 });
-
-  const wo = body.activeWorkOrder ?? {};
-  const k = body.kpis ?? {};
-
-  const row = await prisma.machineKpiSnapshot.create({
-    data: {
-      orgId: machine.orgId,
-      machineId: machine.id,
-
-      workOrderId: wo.id ? String(wo.id) : null,
-      sku: wo.sku ? String(wo.sku) : null,
-
-      target: typeof wo.target === "number" ? wo.target : null,
-      good: typeof wo.good === "number" ? wo.good : null,
-      scrap: typeof wo.scrap === "number" ? wo.scrap : null,
-
-      cycleCount: typeof body.cycle_count === "number" ? body.cycle_count : null,
-      goodParts: typeof body.good_parts === "number" ? body.good_parts : null,
-
-      cycleTime: typeof body.cycleTime === "number" ? body.cycleTime : null,
-
-      availability: typeof k.availability === "number" ? k.availability : null,
-      performance: typeof k.performance === "number" ? k.performance : null,
-      quality: typeof k.quality === "number" ? k.quality : null,
-      oee: typeof k.oee === "number" ? k.oee : null,
-
-      trackingEnabled: typeof body.trackingEnabled === "boolean" ? body.trackingEnabled : null,
-      productionStarted: typeof body.productionStarted === "boolean" ? body.productionStarted : null,
-    },
-  });
-
-  return NextResponse.json({ ok: true, id: row.id, ts: row.ts });
 }