Pembubaran PT (Dissolution, PEMBUBARAN_PT) Flow — Implementation Plan

import { describe, it, expect, afterAll } from "bun:test";
import { db } from "../../lib/db";
import { SubmissionType } from "../../generated/prisma/enums";
import { processorKindForType } from "../../services/submission-dispatch";
import { FLOW_REGISTRY } from "../registry";

/**
 * Task 1 — PEMBUBARAN_PT schema slice + the two compile-forced wiring points
 * (registry key + ProcessorKind case). The registry entry is a TEMPORARY
 * v1-fork stub until Task 6 registers the real defineFlow config. NO new
 * tables (spec §6): likuidator + koran live as ExtractedField rows; the one
 * new column is the registry-roster attendance JSON.
 */
describe("PEMBUBARAN_PT schema + compile-gate", () => {
  const ids: string[] = [];
  afterAll(async () => {
    await db.submission.deleteMany({ where: { id: { in: ids } } });
  });

  it("exposes the new enum value (distinct from PEMBUBARAN_PP)", () => {
    expect(SubmissionType.PEMBUBARAN_PT).toBe("PEMBUBARAN_PT");
    expect(SubmissionType.PEMBUBARAN_PP).toBe("PEMBUBARAN_PP"); // both exist, never aliased
  });

  it("persists rupsKehadiranRegistry rows on Submission", async () => {
    const rows = [
      { nama: "BUDI SANTOSO", persentase: 60, kehadiran: true },
      { nama: "SITI AMINAH", persentase: 40, kehadiran: null },
    ];
    const sub = await db.submission.create({
      data: { type: "PEMBUBARAN_PT", status: "CREATED", rupsKehadiranRegistry: rows },
    });
    ids.push(sub.id);
    const fresh = await db.submission.findUnique({ where: { id: sub.id } });
    expect(fresh?.rupsKehadiranRegistry).toEqual(rows);
    // default null
    const bare = await db.submission.create({ data: { type: "PEMBUBARAN_PT", status: "CREATED" } });
    ids.push(bare.id);
    expect(bare.rupsKehadiranRegistry).toBeNull();
  });

  it("routes the new type to the v2-generic ProcessorKind and a total registry", () => {
    expect(processorKindForType("PEMBUBARAN_PT")).toBe("v2-generic");
    expect(FLOW_REGISTRY.PEMBUBARAN_PT).toBeDefined();
  });
});

  /// Pembubaran PT (SABH id_aksi_transaksi = 12, UUPT Ps.142-147): dissolution of a
  /// REGISTERED PT — the deed dissolves the PT and APPOINTS a likuidator (liquidation
  /// STARTS; contrast Berakhirnya id_aksi 36, which ACCEPTS the likuidator's final
  /// accounting and ENDS it). DISTINCT from PEMBUBARAN_PP (Perseroan Perorangan,
  /// UU CK regime) — exact-equality checks only, never substring matching.
  /// THIRD engine:'v2-generic' FLOW_REGISTRY tenant. VERIFIKATOR-STAGED (submit
  /// creates a VerifikasiPerubahan row; voter roster = oldData.pemegang_saham).
  PEMBUBARAN_PT

  /// PEMBUBARAN_PT registry-roster RUPS-attendance fallback (spec §4.3):
  /// [{ nama, persentase, kehadiran }] written by matchRupsAttendance when the
  /// dissolution deed restates no shareholders — SABH's attendance checkboxes are
  /// against the REGISTRY list, so this is the flow's PRIMARY attendance path.
  /// Consumed by buildPembubaranContext (quorum) and the Kehadiran review card.
  rupsKehadiranRegistry Json?

  // TEMPORARY v1-fork stub — satisfies Record totality until Task 6 registers the
  // real defineFlow(...) entry. processorKindForType already returns "v2-generic",
  // so a premature legacy dispatch throws LOUD (unreachable while the classifier
  // gate keeps the flow dark — BUILT_AKTA_TXN_TYPES flips in Task 7).
  PEMBUBARAN_PT: { engine: "v1-fork", type: "PEMBUBARAN_PT" },

    case "PEMBUBARAN_PT":
      // v2-generic: dispatch resolves FLOW_REGISTRY BEFORE this switch; the
      // switch's "v2-generic" case below is a deliberate unreachable-throw.
      return "v2-generic";

import { describe, it, expect, afterAll, afterEach } from "bun:test";
import { db } from "../../lib/db";
import {
  extractSuratLikuidator,
  runSuratLikuidatorPass,
  LIKUIDATOR_EXTRACTED_FIELD_KEYS,
} from "../surat-likuidator-extract";

const RAW =
  "SURAT PENUNJUKAN LIKUIDATOR\nNomor: 017/SPL/V/2026\nJakarta, 2 Mei 2026\n" +
  "Menunjuk Saudara BUDI HARTONO, S.H. selaku likuidator Perseroan\n" +
  "beralamat di Jalan Melati Raya No. 12, RT. 004/RW. 007,\n" +
  "Kelurahan Cempaka Putih, Kecamatan Menteng, Kode Pos 10310\n" +
  "Telepon: 081234567890, Email: budi.hartono@example.co.id\n" +
  "Dasar penunjukan: Keputusan Rapat Umum Pemegang Saham tanggal 28 April 2026\n" +
  "sebagaimana dimuat dalam Akta Pembubaran Nomor 5.";

function mockLlm(content: object | null, status = 200) {
  const orig = globalThis.fetch;
  globalThis.fetch = (async () =>
    new Response(
      JSON.stringify({ choices: [{ message: { content: content ? JSON.stringify(content) : "" } }] }),
      { status },
    )) as typeof fetch;
  return () => { globalThis.fetch = orig; };
}

const LLM_FULL = {
  nama: "BUDI HARTONO, S.H.", nomor_surat: "017/SPL/V/2026", tanggal_surat: "2 Mei 2026",
  alamat: "Jalan Melati Raya No. 12", rt: "999", rw: "999", kode_pos: "99999",
  kelurahan: "Cempaka Putih", kecamatan: "Menteng",
  telepon: "089999999999", email: "salah@salah.com",
  dasar_penunjukan: "Keputusan Rapat Umum Pemegang Saham tanggal 28 April 2026 sebagaimana dimuat dalam Akta Pembubaran Nomor 5",
};

describe("extractSuratLikuidator (deterministic-first grounded 3B)", () => {
  const origEnv = process.env.CLEANUP_LLM_URL;
  afterEach(() => { process.env.CLEANUP_LLM_URL = origEnv; });

  it("deterministic RT/RW/kodepos/telepon/email WIN over conflicting LLM output", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm(LLM_FULL);
    try {
      const r = await extractSuratLikuidator(RAW);
      expect(r.rt).toBe("004");
      expect(r.rw).toBe("007");
      expect(r.kode_pos).toBe("10310");
      expect(r.telepon).toBe("081234567890");
      expect(r.email).toBe("budi.hartono@example.co.id");
    } finally { restore(); }
  });

  it("grounds LLM values verbatim; token-wise grounding accepts the multi-line dasar_penunjukan", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm(LLM_FULL);
    try {
      const r = await extractSuratLikuidator(RAW);
      expect(r.nama).toBe("BUDI HARTONO, S.H.");
      expect(r.nomor_surat).toBe("017/SPL/V/2026");
      expect(r.kelurahan).toBe("Cempaka Putih");
      // spans two OCR lines — whole-substring grounding would null it; token-wise ≥80% accepts it
      expect(r.dasar_penunjukan).toContain("Keputusan Rapat Umum Pemegang Saham");
    } finally { restore(); }
  });

  it("rejects hallucinated values (not grounded in rawText) → null", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm({ ...LLM_FULL, nama: "SINTA HALUSINASI", kelurahan: "Tanah Abang" });
    try {
      const r = await extractSuratLikuidator(RAW);
      expect(r.nama).toBeNull();
      expect(r.kelurahan).toBeNull();
    } finally { restore(); }
  });

  it("returns all-null LLM fields on outage/empty text — deterministic fields still fire; never throws", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm(null, 500);
    try {
      const r = await extractSuratLikuidator(RAW);
      expect(r.nama).toBeNull();           // LLM-only field
      expect(r.rt).toBe("004");            // deterministic survives outage
      const empty = await extractSuratLikuidator("");
      expect(Object.values(empty).every((v) => v === null)).toBe(true);
    } finally { restore(); }
  });
});

describe("runSuratLikuidatorPass persistence (12 ExtractedField rows, atomic, idempotent-once)", () => {
  const docIds: string[] = [];
  afterAll(async () => { await db.document.deleteMany({ where: { id: { in: docIds } } }); });

  async function seedDoc() {
    const doc = await db.document.create({
      data: {
        filename: "spl.pdf", originalName: "spl.pdf", fileSize: 0, filePath: "/tmp/spl.pdf",
        documentType: "SURAT_LIKUIDATOR", status: "VERIFICATION_READY", rawText: RAW,
      },
    });
    docIds.push(doc.id);
    return doc.id;
  }

  it("persists ALL 12 canonical rows in one shot (0.75 grounded tier; null → FLAGGED)", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm(LLM_FULL);
    try {
      const documentId = await seedDoc();
      await runSuratLikuidatorPass({ submissionId: "s", documentId, rawText: RAW });
      const rows = await db.extractedField.findMany({ where: { documentId } });
      expect(rows.length).toBe(LIKUIDATOR_EXTRACTED_FIELD_KEYS.length);
      const nama = rows.find((r) => r.fieldKey === "likuidator_nama");
      expect(nama?.value).toBe("BUDI HARTONO, S.H.");
      expect(nama?.confidence).toBe(0.75); // "please review" tier — never auto-LOCK
      expect(nama?.status).toBe("EDITABLE");
      const alamat = rows.find((r) => r.fieldKey === "likuidator_alamat");
      expect(alamat?.value).toBe("Jalan Melati Raya No. 12");
    } finally { restore(); }
  });

  it("is idempotent-once: NEVER clobbers existing rows (operator edit survives resume)", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm(LLM_FULL);
    try {
      const documentId = await seedDoc();
      await db.extractedField.create({
        data: { documentId, fieldKey: "likuidator_nama", value: "EDIT OPERATOR", confidence: 1, status: "MANUAL" },
      });
      await runSuratLikuidatorPass({ submissionId: "s", documentId, rawText: RAW });
      const rows = await db.extractedField.findMany({ where: { documentId } });
      expect(rows.length).toBe(1); // any-key → skip-ALL (sound: the write below is atomic)
      expect(rows[0]?.value).toBe("EDIT OPERATOR");
    } finally { restore(); }
  });

  it("skips loudly (no rows) on empty rawText — manual entry path, never an ERROR", async () => {
    const documentId = await seedDoc();
    await runSuratLikuidatorPass({ submissionId: "s", documentId, rawText: "" });
    expect(await db.extractedField.findMany({ where: { documentId } })).toEqual([]);
  });
});

/**
 * Focused, grounded SURAT_LIKUIDATOR extractor — PEMBUBARAN_PT's definitional
 * net-new block (spec §4.3). PENUNJUKAN SHAPE ONLY: the laporan-akhir /
 * pertanggungjawaban is the DISTINCT LAPORAN_LIKUIDASI DocumentType (built in
 * the Berakhirnya flow) — the §4.2 doc-set predicate keys on that distinction,
 * so this extractor must never swallow it (C2).
 *
 * Strategy (memory reference_apostille_extraction_llm — the 3B is brittle on
 * broad prompts, so this is a dedicated single-purpose call, never a widening
 * of any shared prompt):
 *   1. Deterministic regexes FIRST (RT/RW, labeled kodepos, telepon, email) —
 *      they win over LLM output unconditionally.
 *   2. ONE 3B guided-JSON call (CLEANUP_LLM, temperature 0) fills the rest.
 *   3. EVERY LLM value is grounded against rawText: whole-normalized-substring
 *      for scalars; TOKEN-WISE (≥80% of normalized tokens present) for
 *      dasar_penunjukan, which spans lines and would otherwise always null out.
 * Persistence: 12 ExtractedField rows (spec §6 — NO satellite table; buys
 * confirm/bbox/override/rematch wholesale), grounded 0.75 "please review" tier
 * (never auto-LOCK), ONE atomic createMany, IDEMPOTENT-ONCE.
 */
import { db } from "../lib/db";

export interface SuratLikuidatorFields {
  nama: string | null;
  nomor_surat: string | null;
  tanggal_surat: string | null;
  alamat: string | null;
  rt: string | null;
  rw: string | null;
  kode_pos: string | null;
  kelurahan: string | null;
  kecamatan: string | null;
  telepon: string | null;
  email: string | null;
  dasar_penunjukan: string | null;
}

const FIELD_ORDER = [
  "nama", "nomor_surat", "tanggal_surat", "alamat", "rt", "rw", "kode_pos",
  "kelurahan", "kecamatan", "telepon", "email", "dasar_penunjukan",
] as const;

/** Canonical ExtractedField keys — `likuidator_` + the schema key. Exported for
 *  the context builder, rules, routes and tests (ONE source of truth). */
export const LIKUIDATOR_EXTRACTED_FIELD_KEYS = FIELD_ORDER.map((k) => `likuidator_${k}`) as readonly string[];

const NONE: SuratLikuidatorFields = Object.fromEntries(FIELD_ORDER.map((k) => [k, null])) as SuratLikuidatorFields;

/** Deterministic tier — regex-extract BEFORE the LLM; these win unconditionally. */
export function extractLikuidatorDeterministic(rawText: string): Partial<SuratLikuidatorFields> {
  const out: Partial<SuratLikuidatorFields> = {};
  const rtRw = rawText.match(/RT\s*\.?\s*(\d{1,3})\s*[\/.]?\s*RW\s*\.?\s*(\d{1,3})/i);
  if (rtRw) { out.rt = rtRw[1]!; out.rw = rtRw[2]!; }
  const kodePos = rawText.match(/kode\s*pos\s*:?\s*(\d{5})\b/i);
  if (kodePos) out.kode_pos = kodePos[1]!;
  const telepon = rawText.match(/(?:\+62|62|08)\d{7,12}/);
  if (telepon) out.telepon = telepon[0];
  const email = rawText.match(/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/);
  if (email) out.email = email[0];
  return out;
}

const norm = (s: string) => s.toLowerCase().replace(/[^a-z0-9]/g, "");

/** Token-wise grounding for free text spanning OCR lines: ≥80% of the value's
 *  normalized tokens must appear in the haystack. */
function groundTokens(value: string, hay: string): boolean {
  const tokens = value.split(/\s+/).map(norm).filter((t) => t.length > 0);
  if (tokens.length === 0) return false;
  const present = tokens.filter((t) => hay.includes(t)).length;
  return present / tokens.length >= 0.8;
}

export async function extractSuratLikuidator(rawText: string): Promise<SuratLikuidatorFields> {
  if (!rawText.trim()) return { ...NONE };
  const deterministic = extractLikuidatorDeterministic(rawText);

  const url = process.env.CLEANUP_LLM_URL || "";
  const model = process.env.CLEANUP_LLM_MODEL || "cleanup-3b";
  let llm: Partial<Record<keyof SuratLikuidatorFields, string | null>> = {};
  if (url) {
    const system =
      "From an Indonesian surat penunjukan likuidator (liquidator-appointment letter for a PT dissolution), extract: " +
      "nama (the appointed likuidator's full name incl. titles), nomor_surat (the letter number), tanggal_surat (the letter date as written), " +
      "alamat (the likuidator's street address line, WITHOUT RT/RW/kelurahan/kecamatan/kode pos), rt, rw, kode_pos, kelurahan, kecamatan, " +
      "telepon, email, dasar_penunjukan (the legal basis of the appointment, e.g. the RUPS resolution or court order recital). " +
      "Copy VERBATIM from the text; if absent, return null. Never invent. " +
      "Return ONLY JSON {nama, nomor_surat, tanggal_surat, alamat, rt, rw, kode_pos, kelurahan, kecamatan, telepon, email, dasar_penunjukan}.";
    try {
      const res = await fetch(`${url}/chat/completions`, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          model, temperature: 0,
          messages: [
            { role: "system", content: system },
            { role: "user", content: rawText.slice(0, 12000) },
          ],
          guided_json: {
            type: "object",
            properties: Object.fromEntries(FIELD_ORDER.map((k) => [k, { type: ["string", "null"] }])),
            required: [...FIELD_ORDER],
            additionalProperties: false,
          },
        }),
        signal: AbortSignal.timeout(parseInt(process.env.CLEANUP_LLM_TIMEOUT_MS || "30000", 10)),
      });
      if (res.ok) {
        const json = (await res.json()) as { choices?: { message?: { content?: string } }[] };
        const m = (json.choices?.[0]?.message?.content ?? "").match(/\{[\s\S]*\}/);
        if (m) llm = JSON.parse(m[0]) as Partial<Record<keyof SuratLikuidatorFields, string | null>>;
      }
    } catch (err) {
      console.warn("[surat-likuidator] 3B extraction failed:", err);
    }
  }

  const hay = norm(rawText);
  const ground = (v: string | null | undefined): string | null => {
    const s = v ? String(v).trim() : "";
    return s && hay.includes(norm(s)) ? s : null;
  };

  const out: SuratLikuidatorFields = { ...NONE };
  for (const key of FIELD_ORDER) {
    const det = deterministic[key];
    if (det) { out[key] = det; continue; } // deterministic wins
    const raw = llm[key] ? String(llm[key]).trim() : "";
    if (!raw) continue;
    if (key === "dasar_penunjukan") {
      out[key] = groundTokens(raw, hay) ? raw : null; // token-wise — spans lines
    } else {
      out[key] = ground(raw);
    }
  }
  return out;
}

/** The 'surat-likuidator' focused-pass body (invoked by flow-engine focusedPasses). */
export async function runSuratLikuidatorPass(args: { submissionId: string; documentId: string; rawText: string }): Promise<void> {
  const { documentId, rawText } = args;
  if (!rawText.trim()) {
    console.warn(`[surat-likuidator] no rawText for doc ${documentId} — focused pass skipped (manual entry via PUT /likuidator)`);
    return;
  }
  const existing = await db.extractedField.findMany({
    where: { documentId, fieldKey: { in: [...LIKUIDATOR_EXTRACTED_FIELD_KEYS] } },
    select: { id: true },
  });
  // IDEMPOTENT-ONCE, any-key→skip-ALL. Sound because the write below is ONE atomic
  // createMany: a partial row set can no longer exist (the Peleburan-ledger
  // crash-mid-write class is closed for this consumer by construction).
  if (existing.length > 0) return;
  const r = await extractSuratLikuidator(rawText);
  await db.extractedField.createMany({
    data: FIELD_ORDER.map((k) => {
      const value = r[k];
      return {
        documentId,
        fieldKey: `likuidator_${k}`,
        value,
        confidence: value ? 0.75 : 0, // grounded "please review" tier — never auto-LOCK
        status: value ? "EDITABLE" : "FLAGGED",
      };
    }),
  });
}

  "surat-likuidator": async (args) => {
    const { runSuratLikuidatorPass } = await import("../services/surat-likuidator-extract");
    await runSuratLikuidatorPass(args);
  },

    // 6k. SURAT_LIKUIDATOR (surat penunjukan likuidator, Pembubaran PT) — OCR-ONLY.
    // The grounded 12-field extraction runs as the flow-engine 'surat-likuidator'
    // focusedPasses pass, NOT here. Without this case the letter falls through to
    // the generic Akta handler and burns an akta-VLM extraction on a 1-2 page letter.
    if (doc.documentType === "SURAT_LIKUIDATOR") {
      const layoutProvider = await getLayoutProvider("paddleocr");
      const ocr = await layoutProvider.extractTextWithWords(fileBuffer, { unwarp: false, orient: false });
      await db.document.update({
        where: { id: documentId },
        data: { rawText: ocr.rawText ?? "", pageCount: ocr.pageCount ?? 1, status: "VERIFICATION_READY" },
      });
      return;
    }

  const r = await extractBuktiPengumuman(rawText);
  for (const fieldKey of KEYS) {
    const value = r[fieldKey];
    await db.extractedField.create({
      data: {
        documentId, fieldKey, value,
        confidence: value ? 0.75 : 0, // grounded-3B "please review" tier — never auto-LOCK territory
        status: value ? "EDITABLE" : "FLAGGED",
      },
    });
  }

  const r = await extractBuktiPengumuman(rawText);
  // ATOMIC single createMany (was a per-key create loop): a crash mid-loop left a
  // permanent partial row set that the any-key idempotency guard above then
  // preserved forever (Peleburan-ledger carry; hardening trigger = Pembubaran's
  // clipping adoption). All-or-nothing now, so the guard is sound.
  await db.extractedField.createMany({
    data: KEYS.map((fieldKey) => {
      const value = r[fieldKey];
      return {
        documentId, fieldKey, value,
        confidence: value ? 0.75 : 0, // grounded-3B "please review" tier — never auto-LOCK territory
        status: value ? "EDITABLE" : "FLAGGED",
      };
    }),
  });

import { describe, it, expect, afterAll, afterEach } from "bun:test";
import { db } from "../../lib/db";
import { runPembubaranDeedPasses } from "../akta-pembubaran-deed-passes";

const RAW =
  "AKTA PEMBUBARAN PT MAJU MUNDUR\nNomor 5, tanggal 30 April 2026\n" +
  "RUPS memutuskan membubarkan Perseroan dan menunjuk likuidator.\n" +
  "Pengumuman telah dimuat dalam surat kabar harian Media Indonesia tanggal 20 April 2026.";

function mockLlm(content: object) {
  const orig = globalThis.fetch;
  globalThis.fetch = (async () =>
    new Response(JSON.stringify({ choices: [{ message: { content: JSON.stringify(content) } }] }), { status: 200 })) as typeof fetch;
  return () => { globalThis.fetch = orig; };
}

async function seed(withClipping: boolean) {
  const sub = await db.submission.create({ data: { type: "PEMBUBARAN_PT", status: "EXTRACTING" } });
  const akta = await db.document.create({
    data: { filename: "akta.pdf", originalName: "akta.pdf", fileSize: 0, filePath: "/tmp/a.pdf", documentType: "AKTA", status: "VERIFICATION_READY", rawText: RAW },
  });
  await db.submissionDocument.create({
    data: { submissionId: sub.id, documentId: akta.id, classifiedType: "AKTA_PEMBUBARAN", confidence: 1, processingOrder: 0, extractionStatus: "DONE" },
  });
  let clipId: string | null = null;
  if (withClipping) {
    const clip = await db.document.create({
      data: { filename: "koran.pdf", originalName: "koran.pdf", fileSize: 0, filePath: "/tmp/k.pdf", documentType: "BUKTI_PENGUMUMAN", status: "VERIFICATION_READY", rawText: "PENGUMUMAN PEMBUBARAN" },
    });
    clipId = clip.id;
    await db.submissionDocument.create({
      data: { submissionId: sub.id, documentId: clip.id, classifiedType: "BUKTI_PENGUMUMAN", confidence: 1, processingOrder: 6, extractionStatus: "DONE" },
    });
  }
  return { sub, akta, clipId };
}

describe("runPembubaranDeedPasses (deed-inline koran fallback, SHARED extractKoranFields)", () => {
  const subIds: string[] = [];
  const docIds: string[] = [];
  const origEnv = process.env.CLEANUP_LLM_URL;
  afterEach(() => { process.env.CLEANUP_LLM_URL = origEnv; });
  afterAll(async () => {
    await db.submission.deleteMany({ where: { id: { in: subIds } } });
    await db.document.deleteMany({ where: { id: { in: docIds } } });
  });

  it("fires ONLY when zero clippings are uploaded; persists canonical keys on the deed", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm({ tanggal_koran: "20 April 2026", nama_koran: "Media Indonesia" });
    try {
      const { sub, akta } = await seed(false);
      subIds.push(sub.id); docIds.push(akta.id);
      await runPembubaranDeedPasses({ submissionId: sub.id, aktaDocumentId: akta.id, rawText: RAW });
      const nama = await db.extractedField.findUnique({ where: { documentId_fieldKey: { documentId: akta.id, fieldKey: "nama_koran" } } });
      const tgl = await db.extractedField.findUnique({ where: { documentId_fieldKey: { documentId: akta.id, fieldKey: "tanggal_pengumuman" } } });
      expect(nama?.value).toBe("Media Indonesia");
      expect(nama?.confidence).toBe(0.75);
      expect(tgl?.value).toBe("20 April 2026");
    } finally { restore(); }
  });

  it("SKIPS the inline pass when a BUKTI_PENGUMUMAN clipping exists (clipping is the better source)", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm({ tanggal_koran: "20 April 2026", nama_koran: "Media Indonesia" });
    try {
      const { sub, akta, clipId } = await seed(true);
      subIds.push(sub.id); docIds.push(akta.id, clipId!);
      await runPembubaranDeedPasses({ submissionId: sub.id, aktaDocumentId: akta.id, rawText: RAW });
      expect(await db.extractedField.findMany({ where: { documentId: akta.id } })).toEqual([]);
    } finally { restore(); }
  });

  it("is idempotent-once (operator edit survives) and skips loudly on empty rawText", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm({ tanggal_koran: "20 April 2026", nama_koran: "Media Indonesia" });
    try {
      const { sub, akta } = await seed(false);
      subIds.push(sub.id); docIds.push(akta.id);
      await db.extractedField.create({ data: { documentId: akta.id, fieldKey: "nama_koran", value: "EDIT OPERATOR", confidence: 1, status: "MANUAL" } });
      await runPembubaranDeedPasses({ submissionId: sub.id, aktaDocumentId: akta.id, rawText: RAW });
      const rows = await db.extractedField.findMany({ where: { documentId: akta.id } });
      expect(rows.length).toBe(1);
      expect(rows[0]?.value).toBe("EDIT OPERATOR");
      // empty rawText path
      const { sub: s2, akta: a2 } = await seed(false);
      subIds.push(s2.id); docIds.push(a2.id);
      await runPembubaranDeedPasses({ submissionId: s2.id, aktaDocumentId: a2.id, rawText: "" });
      expect(await db.extractedField.findMany({ where: { documentId: a2.id } })).toEqual([]);
    } finally { restore(); }
  });
});

import { describe, it, expect } from "bun:test";
import { transformAktaPerubahanResult } from "../field-transformer";
import type { AktaPerubahanData } from "../../schema/akta-perubahan";

/** Minimal AktaPerubahanData factory — mirror of field-transformer.test.ts's shape. */
function makeData(overrides: Partial<AktaPerubahanData> = {}): AktaPerubahanData {
  return {
    jenis_dokumen: "Akta Pembubaran", akta: { nomor_akta: "5", tanggal_akta: "2026-04-30", judul_akta: null },
    notaris: null, perseroan: null, rups: null, jenis_perubahan: [], modal_baru: null,
    direksi_baru: null, komisaris_baru: null, pemegang_saham_baru: null,
    perubahan_nama: null, perubahan_alamat: null, perubahan_kbli: null,
    perubahan_jangka_waktu: null, perubahan_status_perseroan: null, perubahan_jenis_perseroan: null,
    peralihan_saham: null, pengurus_change_scope: null, pengangkatan_kembali: null,
    penghadap: [], pasal_yang_diubah: null, referensi_akta_pendirian: null,
    referensi_akta_perubahan_sebelumnya: null, saksi_saksi: null, akta_kedua: null,
    ...overrides,
  } as unknown as AktaPerubahanData;
}

describe("akta_kedua dual-deed transformer mappings", () => {
  it("emits the 3 akta_kedua_* rows when the block is populated (dual-deed pembubaran)", () => {
    const r = transformAktaPerubahanResult(
      makeData({ akta_kedua: { nomor_akta: "6", tanggal_akta: "2026-04-30", nama_notaris: "Sari, S.H., M.Kn." } as never }),
      {},
    );
    const byKey = new Map(r.fields.map((f) => [f.fieldKey, f.value]));
    expect(byKey.get("akta_kedua_nomor")).toBe("6");
    expect(byKey.get("akta_kedua_tanggal")).toBe("2026-04-30");
    expect(byKey.get("akta_kedua_nama_notaris")).toBe("Sari, S.H., M.Kn.");
  });

  it("emits ZERO akta_kedua rows when the block is null — v1 perubahan/akuisisi stay byte-identical", () => {
    const r = transformAktaPerubahanResult(makeData(), {});
    expect(r.fields.some((f) => f.fieldKey.startsWith("akta_kedua_"))).toBe(false);
  });
});

import { describe, it, expect, afterAll } from "bun:test";
import { db } from "../../lib/db";
import { matchRupsAttendance } from "../rups-attendance-matcher";

describe("matchRupsAttendance — PEMBUBARAN_PT registry-roster fallback (spec §4.3)", () => {
  const subIds: string[] = [];
  const docIds: string[] = [];
  afterAll(async () => {
    await db.submission.deleteMany({ where: { id: { in: subIds } } });
    await db.document.deleteMany({ where: { id: { in: docIds } } });
  });

  async function seed(opts: { type: "PEMBUBARAN_PT" | "PERUBAHAN_PT"; deedPs: boolean }) {
    const sub = await db.submission.create({
      data: {
        type: opts.type, status: "EXTRACTING",
        oldData: { perseroan: { nama: "PT MAJU MUNDUR", id_perseroan: 4242 }, pemegang_saham: [
          { nama: "BUDI SANTOSO", persentase: 60 },
          { nama: "SITI AMINAH", persentase: 40 },
        ] },
      },
    });
    subIds.push(sub.id);
    const akta = await db.document.create({
      data: { filename: "a.pdf", originalName: "a.pdf", fileSize: 0, filePath: "/tmp/a.pdf", documentType: "AKTA", status: "VERIFICATION_READY" },
    });
    docIds.push(akta.id);
    await db.submissionDocument.create({
      data: { submissionId: sub.id, documentId: akta.id, classifiedType: "AKTA_PEMBUBARAN", confidence: 1, processingOrder: 0, extractionStatus: "DONE" },
    });
    if (opts.deedPs) {
      await db.aktaPemegangSaham.create({
        data: { documentId: akta.id, namaAtauBadanHukum: "BUDI SANTOSO", persentase: 60, orderIndex: 0 },
      });
    }
    const ba = await db.document.create({
      data: { filename: "ba.pdf", originalName: "ba.pdf", fileSize: 0, filePath: "/tmp/b.pdf", documentType: "BERITA_ACARA_RUPS", status: "VERIFICATION_READY" },
    });
    docIds.push(ba.id);
    await db.submissionDocument.create({
      data: { submissionId: sub.id, documentId: ba.id, classifiedType: "BERITA_ACARA_RUPS", confidence: 1, processingOrder: 6, extractionStatus: "DONE" },
    });
    await db.beritaAcaraRupsExtraction.create({
      data: {
        documentId: ba.id,
        attendees: [
          { nama: "Bpk. BUDI SANTOSO", kehadiran: "hadir" },
          { nama: "SITI AMINAH", kehadiran: "tidak_hadir" },
        ],
      },
    });
    return { sub, akta };
  }

  it("writes rupsKehadiranRegistry from oldData.pemegang_saham when the deed restates no roster", async () => {
    const { sub } = await seed({ type: "PEMBUBARAN_PT", deedPs: false });
    const r = await matchRupsAttendance(sub.id, db);
    expect(r.matched).toBe(2);
    const fresh = await db.submission.findUnique({ where: { id: sub.id } });
    expect(fresh?.rupsKehadiranRegistry).toEqual([
      { nama: "BUDI SANTOSO", persentase: 60, kehadiran: true },   // honorific-stripped name match
      { nama: "SITI AMINAH", persentase: 40, kehadiran: false },
    ]);
  });

  it("deed-roster path still wins when the deed DOES restate shareholders (AKTA_PEMBUBARAN now accepted)", async () => {
    const { sub, akta } = await seed({ type: "PEMBUBARAN_PT", deedPs: true });
    const r = await matchRupsAttendance(sub.id, db);
    expect(r.matched).toBe(1);
    const ps = await db.aktaPemegangSaham.findFirst({ where: { documentId: akta.id } });
    expect(ps?.kehadiranRups).toBe(true);
    const fresh = await db.submission.findUnique({ where: { id: sub.id } });
    expect(fresh?.rupsKehadiranRegistry).toBeNull(); // fallback did not fire
  });

  it("fallback is PEMBUBARAN_PT-scoped: a roster-less PERUBAHAN_PT never writes the JSON", async () => {
    const { sub } = await seed({ type: "PERUBAHAN_PT", deedPs: false });
    await matchRupsAttendance(sub.id, db);
    const fresh = await db.submission.findUnique({ where: { id: sub.id } });
    expect(fresh?.rupsKehadiranRegistry).toBeNull();
  });
});

/**
 * PEMBUBARAN_PT hooks.afterAktaExtraction body (spec §4.3). ONE pass: the
 * deed-INLINE koran fallback via the SHARED parameterized extractKoranFields
 * (built in Peleburan — consumed here, never re-implemented; never broaden the
 * prompt, pass docContext). Fires ONLY when zero BUKTI_PENGUMUMAN clippings are
 * uploaded: the clipping pass (focusedPasses) is the better source, and skipping
 * saves a 3B call + avoids stale deed values shadowing the clipping in review.
 * IDEMPOTENT-ONCE + atomic createMany (engine resume never clobbers operator
 * edits). Log-and-continue is enforced by the engine (processor.ts try/catch).
 * NOTE: no source-refs pass here — pembubaran is SINGLE-company (companyLookup:
 * true); the peleburan 35B sources pass is NOT a template for this flow.
 */
import { db } from "../lib/db";
import { extractKoranFields } from "./akta-koran-extract";

export async function runPembubaranDeedPasses(a: { submissionId: string; aktaDocumentId: string; rawText: string }): Promise<void> {
  const { submissionId, aktaDocumentId, rawText } = a;
  if (!rawText.trim()) {
    console.warn(`[pembubaran-deed] no rawText for akta ${aktaDocumentId} — inline koran pass skipped (manual entry in the Koran card)`);
    return;
  }
  const clippingCount = await db.submissionDocument.count({
    where: { submissionId, document: { documentType: "BUKTI_PENGUMUMAN" } },
  });
  if (clippingCount > 0) return; // clipping wins — inline fallback only at zero clippings (spec §4.3)

  const existing = await db.extractedField.findMany({
    where: { documentId: aktaDocumentId, fieldKey: { in: ["nama_koran", "tanggal_pengumuman"] } },
    select: { id: true },
  });
  if (existing.length > 0) return; // idempotent-once — operator edits survive resume

  const koran = await extractKoranFields(rawText, { docContext: "akta pembubaran perseroan terbatas (likuidasi)" });
  await db.extractedField.createMany({
    data: [
      { documentId: aktaDocumentId, fieldKey: "nama_koran", value: koran.nama_koran, confidence: koran.nama_koran ? 0.75 : 0, status: koran.nama_koran ? "EDITABLE" : "FLAGGED" },
      { documentId: aktaDocumentId, fieldKey: "tanggal_pengumuman", value: koran.tanggal_koran, confidence: koran.tanggal_koran ? 0.75 : 0, status: koran.tanggal_koran ? "EDITABLE" : "FLAGGED" },
    ],
  });
}