"use strict";

const test = require("node:test");
const assert = require("node:assert/strict");
const pet = require("../pet-runtime.js");
const bridge = require("../bridge-client.js");
const wireContract = require("../../Contracts/erp-agent-wire-contract-v1.json");

test("Codex v1 atlas geometry and all nine rows are exact", () => {
  assert.deepEqual(pet.ATLAS, {
    columns: 8,
    rows: 9,
    frameWidth: 192,
    frameHeight: 208,
    width: 1536,
    height: 1872
  });
  assert.equal(pet.ANIMATIONS.idle.row, 0);
  assert.equal(pet.ANIMATIONS["running-right"].frames, 8);
  assert.equal(pet.ANIMATIONS["running-left"].row, 2);
  assert.deepEqual(pet.ANIMATIONS.waiting.durations, [150, 150, 150, 150, 150, 260]);
  assert.equal(pet.ANIMATIONS.review.row, 8);
});

test("semantic ERP states map to visible pet states", () => {
  assert.equal(pet.animationForSemanticState("thinking"), "review");
  assert.equal(pet.animationForSemanticState("awaiting_confirmation"), "waiting");
  assert.equal(pet.animationForSemanticState("executing"), "running");
  assert.equal(pet.animationForSemanticState("success"), "jumping");
  assert.equal(pet.animationForSemanticState("error"), "failed");
  assert.throws(() => pet.animationForSemanticState("write_without_confirmation"), /Unknown pet state/);
});

test("frame CSS selects the correct atlas cell", () => {
  const first = pet.frameStyle("idle", 0, "asset.webp");
  const last = pet.frameStyle("review", 5, "asset.webp");
  assert.equal(first.backgroundSize, "800% 900%");
  assert.equal(first.backgroundPosition, "0% 0%");
  assert.equal(last.backgroundPosition, (5 / 7) * 100 + "% 100%");
  assert.throws(() => pet.frameStyle("waving", 4, "asset.webp"), RangeError);
});

test("animator follows per-frame duration and cancels stale schedules", () => {
  const scheduled = [];
  const element = { style: {}, dataset: {} };
  const animator = new pet.AtlasAnimator(element, {
    setTimer(callback, delay) {
      scheduled.push({ callback, delay });
      return scheduled.length;
    },
    clearTimer() {}
  });
  animator.play("waving");
  assert.equal(scheduled[0].delay, 140);
  scheduled[0].callback();
  assert.equal(element.dataset.frame, "1");
  animator.play("waiting");
  assert.equal(element.dataset.animation, "waiting");
  scheduled[1].callback();
  assert.equal(element.dataset.animation, "waiting");
});

test("bridge client keeps one idempotency key for retries of the same plan", async () => {
  const requests = [];
  const transport = {
    async send(request) {
      requests.push(request);
      return validResponse(request, executionData());
    }
  };
  const client = new bridge.BridgeClient(transport, { clientSessionId: "session-test" });
  const planId = "0123456789abcdef0123456789abcdef";
  const correlationId = "plan-correlation-01234567";
  await client.execute(planId, correlationId);
  await client.execute(planId, correlationId);
  assert.equal(requests.length, 2);
  assert.equal(requests[0].payload.idempotencyKey, requests[1].payload.idempotencyKey);
  assert.equal(requests[0].clientSessionId, "session-test");
  assert.equal(requests[0].correlationId, correlationId);
  assert.equal(requests[1].correlationId, correlationId);
});

test("bridge client gives a followup plan an independent idempotency key", async () => {
  const requests = [];
  const transport = {
    async send(request) {
      requests.push(request);
      return validResponse(request, executionData());
    }
  };
  const client = new bridge.BridgeClient(transport, { clientSessionId: "session-followup" });
  await client.execute(
    "0123456789abcdef0123456789abcdef",
    "plan-correlation-01234567");
  await client.execute(
    "fedcba9876543210fedcba9876543210",
    "plan-correlation-01234567");
  assert.notEqual(requests[0].payload.idempotencyKey, requests[1].payload.idempotencyKey);
});

test("bridge client binds followup plans to the trusted ERP correlation", async () => {
  const correlationId = "plan-correlation-76543210";
  const followupPlan = {
    planId: "fedcba9876543210fedcba9876543210",
    commandName: "hr.leave.submit"
  };
  const client = new bridge.BridgeClient({
    async send(request) {
      return validResponse(request, executionData({
        followupPlan: { ...followupPlan, bridgeCorrelationId: "forged-correlation" }
      }));
    }
  }, { clientSessionId: "session-correlated-followup" });

  const data = await client.execute(
    "0123456789abcdef0123456789abcdef",
    correlationId);
  assert.equal(data.bridgeCorrelationId, correlationId);
  assert.equal(data.followupPlan.bridgeCorrelationId, correlationId);
  assert.equal(data.followupPlan.planId, followupPlan.planId);
});

test("bridge client binds response protocol request and correlation", async () => {
  const mismatches = [
    request => ({ ...validResponse(request, {}), protocolVersion: "2.0" }),
    request => ({ ...validResponse(request, {}), requestId: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }),
    request => ({ ...validResponse(request, {}), correlationId: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" }),
    request => ({ ...validResponse(request, {}), unexpected: true }),
    request => ({ ...validResponse(request, {}), success: 1 })
  ];
  for (const makeResponse of mismatches) {
    const client = new bridge.BridgeClient({
      async send(request) { return makeResponse(request); }
    }, { clientSessionId: "session-protocol" });
    await assert.rejects(
      client.health(),
      error => error && error.code === "bridge_protocol_error"
    );
  }
});

test("bridge client preserves a valid business error only after binding", async () => {
  const recovery = {
    action: "inspect_existing_record",
    retryable: false,
    planInvalidated: true,
    message: "先查询现有发票，再重新生成预览。"
  };
  const client = new bridge.BridgeClient({
    async send(request) {
      return {
        ...validResponse(request, { recovery }),
        success: false,
        code: "duplicate_invoice",
        message: "该供应商的发票号码已经存在。"
      };
    }
  }, { clientSessionId: "session-business-error" });
  let boundError;
  await assert.rejects(
    client.health(),
    error => {
      boundError = error;
      return error
        && error.code === "duplicate_invoice"
        && error.message === "该供应商的发票号码已经存在。"
        && error.response.data.recovery.action === "inspect_existing_record";
    }
  );
  const summary = pet.bridgeFailureSummary(boundError);
  assert.equal(summary.planInvalidated, true);
  assert.equal(summary.retryable, false);
  assert.match(summary.text, /下一步：先查询现有发票.*错误码：duplicate_invoice/);
  assert.match(summary.text, /关联 ID：/);
  const timeout = pet.bridgeFailureSummary({
    code: "bridge_timeout",
    message: "untrusted SQL SELECT password"
  });
  assert.equal(timeout.retryable, true);
  assert.equal(timeout.planInvalidated, false);
  assert.doesNotMatch(timeout.text, /password|SELECT/);

  const malformedRecoveries = [
    {},
    { recovery: { ...recovery, action: "run_sql" } },
    { recovery: { ...recovery, retryable: "false" } },
    { recovery: { ...recovery, sql: "select secret" } },
    { recovery: { ...recovery, message: "下一步\n执行" } }
  ];
  for (const data of malformedRecoveries) {
    const malformedClient = new bridge.BridgeClient({
      async send(request) {
        return {
          ...validResponse(request, data),
          success: false,
          code: "duplicate_invoice",
          message: "该供应商的发票号码已经存在。"
        };
      }
    }, { clientSessionId: "session-malformed-recovery" });
    await assert.rejects(
      malformedClient.health(),
      error => error && error.code === "bridge_protocol_error"
    );
  }
});

test("diagnostic execution receipt is strict and gives a safe next-turn summary", async () => {
  const correlationId = "diagnostic-correlation-01234567";
  const client = new bridge.BridgeClient({
    async send(request) {
      return validResponse(
        request,
        diagnosticExecutionData(request.correlationId));
    }
  }, { clientSessionId: "session-diagnostic-result" });
  const data = await client.execute(
    "0123456789abcdef0123456789abcdef",
    correlationId);
  const summary = pet.diagnosticExecutionSummary(data.result);
  assert.match(summary, /数据库字段不存在.*下一轮对话.*具体哪里配置错了/);
  assert.doesNotMatch(summary, /password|SELECT|physical_table/i);

  const malformedClient = new bridge.BridgeClient({
    async send(request) {
      const responseData = diagnosticExecutionData(request.correlationId);
      responseData.result.data.sql = "SELECT password FROM physical_table";
      return validResponse(request, responseData);
    }
  }, { clientSessionId: "session-diagnostic-injection" });
  await assert.rejects(
    malformedClient.execute(
      "fedcba9876543210fedcba9876543210",
      correlationId),
    error => error && error.code === "bridge_protocol_error"
  );
});

test("bridge client rejects invalid request shapes before transport", async () => {
  let calls = 0;
  const client = new bridge.BridgeClient({
    async send(request) {
      calls += 1;
      return validResponse(request, {});
    }
  }, { clientSessionId: "session-request-shape" });
  await assert.rejects(client.plan("module.diagnose", []), /计划请求格式无效/);
  await assert.rejects(
    client.execute("not-a-server-plan", "plan-correlation-01234567"),
    /执行请求格式无效/);
  await assert.rejects(
    client.execute("0123456789abcdef0123456789abcdef"),
    /执行请求格式无效/);
  assert.equal(calls, 0);
});

test("atlas validation rejects dimensions that could crop guga", () => {
  assert.equal(pet.validateAtlas(1536, 1872), true);
  assert.equal(pet.validateAtlas(1536, 1792), false);
});

test("anchor click focuses a hover-opened panel before allowing toggle close", () => {
  assert.equal(pet.panelOpenAfterAnchorClick(false, false), true);
  assert.equal(pet.panelOpenAfterAnchorClick(true, true), true);
  assert.equal(pet.panelOpenAfterAnchorClick(true, false), false);
  assert.throws(
    () => pet.panelOpenAfterAnchorClick("open", false),
    TypeError);
});

test("pet quick actions are fixed context-aware prompts", () => {
  assert.match(
    pet.quickActionPrompt("purchase_invoice_entry"),
    /先读取当前 ERP 上下文和能力.*不要生成写入计划/
  );
  assert.match(
    pet.quickActionPrompt("leave_request"),
    /原始日期表达与时段.*不得替我补全或猜测/
  );
  assert.equal(
    pet.quickActionPrompt("current_module_help"),
    "当前 ERP 界面有哪些功能？请先读取实时上下文，并只根据当前模块的用户级功能说明回答。"
  );
  assert.match(
    pet.quickActionPrompt("current_module_diagnosis"),
    /只读配置诊断.*不要复现初始化.*不要生成修复 SQL/
  );
  assert.match(
    pet.quickActionPrompt("workflow_readiness"),
    /ERP 内置管理员.*adapters\.status.*不要泄露配置证据、SQL 或物理字段/
  );
  assert.throws(
    () => pet.quickActionPrompt("execute_current_module"),
    /Unknown pet quick action/
  );
});

test("admin workflow readiness quick action requires trusted administrator scope", () => {
  const context = {
    userId: "1",
    userName: "管理员",
    accountBook: "测试账套",
    subSystemId: "SCM",
    subSystemName: "供应链",
    databaseScopeFingerprint: "b".repeat(64),
    isAdministrator: true
  };
  assert.equal(pet.quickActionVisible("workflow_readiness", context), true);
  assert.equal(pet.quickActionVisible("purchase_invoice_entry", null), true);

  const ordinaryUser = structuredClone(context);
  ordinaryUser.userId = "2";
  ordinaryUser.userName = "普通用户";
  ordinaryUser.isAdministrator = false;
  assert.equal(pet.quickActionVisible("workflow_readiness", ordinaryUser), false);

  const malformedAdministrator = structuredClone(context);
  malformedAdministrator.databaseScopeFingerprint = "B".repeat(64);
  assert.equal(
    pet.quickActionVisible("workflow_readiness", malformedAdministrator),
    false
  );
  assert.throws(
    () => pet.quickActionVisible("unknown_action", context),
    /Unknown pet quick action/
  );
});

test("ERP session scope summary is complete bounded and database-evidence only", () => {
  const context = {
    userId: "USER-001",
    userName: "测试用户",
    accountBook: "生产账套甲",
    subSystemId: "SCM-01",
    subSystemName: "采购管理",
    databaseScopeFingerprint: "a".repeat(64),
    isAdministrator: false
  };
  const summary = pet.erpSessionScopeSummary(context);
  assert.equal(summary.complete, true);
  assert.equal(summary.userId, "USER-001");
  assert.equal(summary.accountBook, "生产账套甲");
  assert.equal(summary.subSystemId, "SCM-01");
  assert.equal(summary.databaseEvidence, "a".repeat(12));
  assert.equal("databaseScopeFingerprint" in summary, false);

  const missingAccount = structuredClone(context);
  delete missingAccount.accountBook;
  assert.equal(pet.erpSessionScopeSummary(missingAccount).complete, false);

  const uppercaseFingerprint = structuredClone(context);
  uppercaseFingerprint.databaseScopeFingerprint = "A".repeat(64);
  assert.equal(
    pet.erpSessionScopeSummary(uppercaseFingerprint).complete,
    false);

  const controlText = structuredClone(context);
  controlText.userName = "测试\u0085用户";
  assert.equal(pet.erpSessionScopeSummary(controlText).complete, false);

  const forgedAdministrator = structuredClone(context);
  forgedAdministrator.isAdministrator = "false";
  assert.equal(
    pet.erpSessionScopeSummary(forgedAdministrator).complete,
    false);
  assert.equal(pet.erpSessionScopeSummary(null).complete, false);
});

test("purchase execution requires complete trusted header and line previews", () => {
  const plan = structuredClone(wireContract.scenarios.find(
    scenario => scenario.name === "purchase_resolve_to_create").plan);
  const preview = pet.purchaseLinePreview(plan);
  assert.equal(preview.required, true);
  assert.equal(preview.complete, true);
  assert.equal(preview.header.invoiceNumber, "INV-CONTRACT-1");
  assert.equal(preview.header.sourceDocumentCount, 1);
  assert.equal(preview.lines[0].sourceOrderNumber, "PO-1");
  assert.equal(pet.isExecutablePlan(plan), true);

  const missingSupplier = structuredClone(plan);
  delete missingSupplier.preview["供应商"];
  delete missingSupplier.data.preview["供应商"];
  assert.equal(pet.purchaseLinePreview(missingSupplier).complete, false);
  assert.equal(pet.isExecutablePlan(missingSupplier), false);

  const forgedHeaderTotal = structuredClone(plan);
  forgedHeaderTotal.preview["价税合计"] = 999;
  forgedHeaderTotal.data.preview["价税合计"] = 999;
  assert.equal(pet.purchaseLinePreview(forgedHeaderTotal).complete, false);
  assert.equal(pet.isExecutablePlan(forgedHeaderTotal), false);

  const forgedLineCount = structuredClone(plan);
  forgedLineCount.preview["发票行数"] = 2;
  forgedLineCount.data.preview["发票行数"] = 2;
  assert.equal(pet.purchaseLinePreview(forgedLineCount).complete, false);
  assert.equal(pet.isExecutablePlan(forgedLineCount), false);

  const missingQuantity = structuredClone(plan);
  delete missingQuantity.data.lineMatches[0].invoiceQuantity;
  assert.equal(pet.purchaseLinePreview(missingQuantity).complete, false);
  assert.equal(pet.isExecutablePlan(missingQuantity), false);

  const ambiguous = structuredClone(plan);
  ambiguous.data.lineMatches[0].candidateCount = 2;
  assert.equal(pet.purchaseLinePreview(ambiguous).complete, false);
  assert.equal(pet.isExecutablePlan(ambiguous), false);

  assert.equal(pet.previewReviewComplete(0, 340, 800), false);
  assert.equal(pet.previewReviewComplete(458, 340, 800), true);
  assert.equal(pet.previewReviewComplete(460, 340, 800), true);
  assert.equal(pet.previewReviewComplete(Number.NaN, 340, 800), false);
});

test("leave create and submit require complete trusted confirmation previews", () => {
  const createPlan = wireContract.scenarios.find(
    scenario => scenario.name === "leave_resolve_to_create").plan;
  const createPreview = pet.leaveConfirmationPreview(createPlan);
  assert.equal(createPreview.required, true);
  assert.equal(createPreview.complete, true);
  assert.equal(createPreview.employeeId, "EMP-1");
  assert.equal(createPreview.calculatedHours, 4);
  assert.equal(pet.isExecutablePlan(createPlan), true);

  const unicodeErpCode = structuredClone(createPlan);
  unicodeErpCode.preview["员工"] = "员工一号";
  unicodeErpCode.data.preview["员工"] = "员工一号";
  assert.equal(pet.leaveConfirmationPreview(unicodeErpCode).complete, true);

  const missingReason = structuredClone(createPlan);
  delete missingReason.preview["原因"];
  delete missingReason.data.preview["原因"];
  assert.equal(pet.leaveConfirmationPreview(missingReason).complete, false);
  assert.equal(pet.isExecutablePlan(missingReason), false);

  const forgedSubmitIntent = structuredClone(createPlan);
  forgedSubmitIntent.preview["创建后提交"] = true;
  forgedSubmitIntent.data.preview["创建后提交"] = true;
  assert.equal(pet.leaveConfirmationPreview(forgedSubmitIntent).complete, false);
  assert.equal(pet.isExecutablePlan(forgedSubmitIntent), false);

  const zonedTime = structuredClone(createPlan);
  zonedTime.preview["开始时间"] = "2026-08-12T13:00:00+08:00";
  zonedTime.data.preview["开始时间"] = "2026-08-12T13:00:00+08:00";
  assert.equal(pet.leaveConfirmationPreview(zonedTime).complete, false);

  const submitPlan = wireContract.scenarios.find(
    scenario => scenario.name === "leave_submit_followup").plan;
  assert.equal(pet.leaveConfirmationPreview(submitPlan).complete, true);
  assert.equal(pet.isExecutablePlan(submitPlan), true);
  const forgedAction = structuredClone(submitPlan);
  forgedAction.preview["动作"] = "删除申请";
  forgedAction.data.preview["动作"] = "删除申请";
  assert.equal(pet.leaveConfirmationPreview(forgedAction).complete, false);
  assert.equal(pet.isExecutablePlan(forgedAction), false);
});

test("initialization trace requires complete scope limits and risk disclosure", () => {
  const plan = wireContract.scenarios.find(
    scenario => scenario.name === "module_trace_initialization").plan;
  const preview = pet.initializationTracePreview(plan);
  assert.equal(preview.required, true);
  assert.equal(preview.complete, true);
  assert.equal(preview.moduleName, "采购订单");
  assert.equal(preview.forceTerminationSupported, false);
  assert.equal(pet.isExecutablePlan(plan), true);

  const missingModuleName = structuredClone(plan);
  delete missingModuleName.preview.moduleName;
  delete missingModuleName.data.preview.moduleName;
  assert.equal(pet.initializationTracePreview(missingModuleName).complete, false);
  assert.equal(pet.isExecutablePlan(missingModuleName), false);

  const forcedTermination = structuredClone(plan);
  forcedTermination.preview.forceTerminationSupported = true;
  forcedTermination.data.preview.forceTerminationSupported = true;
  assert.equal(pet.initializationTracePreview(forcedTermination).complete, false);
  assert.equal(pet.isExecutablePlan(forcedTermination), false);

  const changedLimit = structuredClone(plan);
  changedLimit.preview.maxEvents = 201;
  changedLimit.data.preview.maxEvents = 201;
  changedLimit.data.maxEvents = 201;
  assert.equal(pet.initializationTracePreview(changedLimit).complete, false);

  const missingWarning = structuredClone(plan);
  missingWarning.warnings = [];
  assert.equal(pet.initializationTracePreview(missingWarning).complete, false);
  assert.equal(pet.isExecutablePlan(missingWarning), false);
});

test("dynamic module create requires bounded opaque master and detail previews", () => {
  const plan = structuredClone(wireContract.scenarios.find(
    scenario => scenario.name === "dynamic_module_resolve_to_create").plan);
  const preview = pet.dynamicModuleConfirmationPreview(plan);
  assert.equal(preview.required, true);
  assert.equal(preview.complete, true);
  assert.equal(preview.mode, "create");
  assert.equal(preview.totalValues, 2);
  assert.equal(preview.masterValues[0].parameterId, "m0123456789abcdef");
  assert.equal(preview.detailRows[0].values[0].value, "第一行");
  assert.equal(pet.isExecutablePlan(plan), true);

  const emptyValue = structuredClone(plan);
  emptyValue.preview.masterValues[0].value = "";
  bindDynamicCreateProjections(emptyValue);
  assert.equal(pet.dynamicModuleConfirmationPreview(emptyValue).complete, true);

  const projectionMismatch = structuredClone(plan);
  projectionMismatch.data.parameterPreview.masterValues[0].value = "被篡改";
  assert.equal(
    pet.dynamicModuleConfirmationPreview(projectionMismatch).complete,
    false);
  assert.equal(pet.isExecutablePlan(projectionMismatch), false);

  const physicalFieldLeak = structuredClone(plan);
  physicalFieldLeak.preview.masterValues[0].physicalField = "CUSTOMER_NAME";
  bindDynamicCreateProjections(physicalFieldLeak);
  assert.equal(
    pet.dynamicModuleConfirmationPreview(physicalFieldLeak).complete,
    false);

  const duplicateParameter = structuredClone(plan);
  duplicateParameter.preview.masterValues.push(
    structuredClone(duplicateParameter.preview.masterValues[0]));
  bindDynamicCreateProjections(duplicateParameter);
  assert.equal(
    pet.dynamicModuleConfirmationPreview(duplicateParameter).complete,
    false);

  const wrongRowNumber = structuredClone(plan);
  wrongRowNumber.preview.detailRows[0].rowNumber = 2;
  bindDynamicCreateProjections(wrongRowNumber);
  assert.equal(
    pet.dynamicModuleConfirmationPreview(wrongRowNumber).complete,
    false);

  const controlCharacter = structuredClone(plan);
  controlCharacter.preview.detailRows[0].values[0].value = "第一行\u0085";
  bindDynamicCreateProjections(controlCharacter);
  assert.equal(
    pet.dynamicModuleConfirmationPreview(controlCharacter).complete,
    false);

  const aggregateTooLarge = structuredClone(plan);
  aggregateTooLarge.preview.masterValues = Array.from({ length: 5 }, (_, index) => ({
    parameterId: "m" + index.toString(16).padStart(16, "0"),
    label: "大字段" + index,
    valueType: "string",
    value: "值".repeat(30000)
  }));
  bindDynamicCreateProjections(aggregateTooLarge);
  assert.equal(
    pet.dynamicModuleConfirmationPreview(aggregateTooLarge).complete,
    false);

  const exposedBlocker = structuredClone(plan);
  exposedBlocker.data.writeExecutionBlocker = "adapter_missing";
  assert.equal(
    pet.dynamicModuleConfirmationPreview(exposedBlocker).complete,
    false);

  const changedVersion = structuredClone(plan);
  changedVersion.commandVersion = "2.0";
  assert.equal(pet.dynamicModuleConfirmationPreview(changedVersion).complete, false);
  assert.equal(pet.isExecutablePlan(changedVersion), false);
});

test("dynamic module update requires a bounded concurrent before-after preview", () => {
  const plan = structuredClone(wireContract.scenarios.find(
    scenario => scenario.name === "dynamic_module_resolve_to_update").plan);
  const preview = pet.dynamicModuleConfirmationPreview(plan);
  assert.equal(preview.required, true);
  assert.equal(preview.complete, true);
  assert.equal(preview.mode, "update");
  assert.equal(preview.recordDisplay, "客户 C-001 / 朗速客户");
  assert.equal(preview.changes[0].previousValue, "100.00");
  assert.equal(preview.changes[0].newValue, "120.50");
  assert.equal(pet.isExecutablePlan(plan), true);

  const missingPrevious = structuredClone(plan);
  delete missingPrevious.preview.changes[0].previousValue;
  bindDynamicUpdateProjection(missingPrevious);
  assert.equal(
    pet.dynamicModuleConfirmationPreview(missingPrevious).complete,
    false);

  const noActualChange = structuredClone(plan);
  noActualChange.preview.changes[0].newValue = "100.00";
  bindDynamicUpdateProjection(noActualChange);
  assert.equal(
    pet.dynamicModuleConfirmationPreview(noActualChange).complete,
    false);
  assert.equal(pet.isExecutablePlan(noActualChange), false);

  const physicalFieldLeak = structuredClone(plan);
  physicalFieldLeak.preview.changes[0].columnName = "CREDIT_LIMIT";
  bindDynamicUpdateProjection(physicalFieldLeak);
  assert.equal(
    pet.dynamicModuleConfirmationPreview(physicalFieldLeak).complete,
    false);

  const duplicateParameter = structuredClone(plan);
  const duplicate = structuredClone(duplicateParameter.preview.changes[0]);
  duplicate.newValue = "130.00";
  duplicateParameter.preview.changes.push(duplicate);
  bindDynamicUpdateProjection(duplicateParameter);
  assert.equal(
    pet.dynamicModuleConfirmationPreview(duplicateParameter).complete,
    false);

  const unsafeValue = structuredClone(plan);
  unsafeValue.preview.changes[0].newValue = "120.50\u0000";
  bindDynamicUpdateProjection(unsafeValue);
  assert.equal(
    pet.dynamicModuleConfirmationPreview(unsafeValue).complete,
    false);

  const projectionMismatch = structuredClone(plan);
  projectionMismatch.data.preview.changes[0].newValue = "999.99";
  assert.equal(
    pet.dynamicModuleConfirmationPreview(projectionMismatch).complete,
    false);

  const forgedAdapter = structuredClone(plan);
  forgedAdapter.data.adapter.evidenceSha256 = "not-a-hash";
  assert.equal(
    pet.dynamicModuleConfirmationPreview(forgedAdapter).complete,
    false);
  assert.equal(pet.isExecutablePlan(forgedAdapter), false);
});

test("atlas asset must decode at the exact production dimensions", async () => {
  const loaded = await pet.loadAtlasAsset("https://asset.test/guga.webp", {
    createImage: () => fakeImage(1536, 1872)
  });
  assert.deepEqual(loaded, {
    url: "https://asset.test/guga.webp",
    width: 1536,
    height: 1872
  });
});

test("atlas asset fails closed on crop corruption and timeout", async () => {
  await assert.rejects(
    pet.loadAtlasAsset("https://asset.test/cropped.webp", {
      createImage: () => fakeImage(1536, 1792)
    }),
    error => error && error.code === "pet_sprite_dimensions_invalid"
  );
  await assert.rejects(
    pet.loadAtlasAsset("https://asset.test/corrupt.webp", {
      createImage: () => fakeImage(1536, 1872, true)
    }),
    error => error && error.code === "pet_sprite_decode_failed"
  );
  await assert.rejects(
    pet.loadAtlasAsset("https://asset.test/hung.webp", {
      createImage: () => ({ naturalWidth: 0, naturalHeight: 0 }),
      setTimer(callback) { callback(); return 1; },
      clearTimer() {}
    }),
    error => error && error.code === "pet_sprite_load_timeout"
  );
});

test("invalid server plans can never enable execution", () => {
  assert.equal(pet.isExecutablePlan({
    planId: "p1", valid: true, executionAllowed: true, risk: "write"
  }), true);
  assert.equal(pet.isExecutablePlan({
    planId: "p2", valid: true, executionAllowed: true, risk: "navigate"
  }), true);
  assert.equal(pet.isExecutablePlan({
    planId: "p3", valid: true, executionAllowed: true, risk: "critical"
  }), true);
  assert.equal(pet.isExecutablePlan({
    planId: "p4", valid: true, executionAllowed: false, risk: "draft"
  }), false);
  assert.equal(pet.isExecutablePlan({
    planId: "p5", valid: true, executionAllowed: false, risk: "read"
  }), false);
  assert.equal(pet.isExecutablePlan({
    planId: "p6", valid: false, executionAllowed: true, risk: "write"
  }), false);
  assert.equal(pet.isExecutablePlan({ valid: true, executionAllowed: true, risk: "write" }), false);
  assert.equal(pet.isExecutablePlan(null), false);
});

function validResponse(request, data) {
  return {
    protocolVersion: "1.0",
    requestId: request.requestId,
    correlationId: request.correlationId,
    success: true,
    code: "ok",
    message: null,
    data: data || {}
  };
}

function executionData(overrides) {
  return {
    result: {
      success: true,
      code: "purchase_document_created",
      message: "采购业务单据已创建。",
      recordId: null,
      replayed: false,
      data: {}
    },
    followupPlan: null,
    followupCode: null,
    ...(overrides || {})
  };
}

function diagnosticExecutionData(correlationId) {
  return executionData({
    result: {
      success: true,
      code: "initialization_failure_captured",
      message: "已捕获模块初始化失败的诊断证据。",
      recordId: "hr_4011",
      replayed: false,
      data: {
        diagnosticContextSchemaVersion: "1.0",
        diagnosticId: "diag-0123456789abcdef0123456789abcdef",
        correlationId,
        evidencePersisted: true,
        evidenceContentHash: "b".repeat(64),
        outcome: "failed",
        primaryFindingCode: "missing_column",
        moduleOpenSucceeded: false,
        eventCount: 1,
        failedEventCount: 1,
        slowEventCount: 0,
        traceTruncated: false,
        summaryTruncated: false,
        findings: [{
          severity: "error",
          code: "missing_column",
          category: "low_code_configuration",
          stage: "initialization_sql",
          confidence: "observed",
          message: "初始化引用的数据库字段不存在。",
          recommendation: "检查低代码字段映射、客户扩展字段和账套升级版本。",
          occurrenceCount: 1,
          sqlFingerprint: "c".repeat(64),
          caller: "caller_0001"
        }],
        staticDiagnosis: {
          moduleCode: "hr_4011",
          moduleKind: "base",
          healthy: false,
          issueCount: 1,
          issues: [{
            severity: "error",
            code: "base.fields_missing",
            source: "base_field_config"
          }]
        },
        contextAvailable: true
      }
    }
  });
}

function fakeImage(width, height, decodeFails) {
  const image = {
    naturalWidth: width,
    naturalHeight: height,
    async decode() {
      if (decodeFails) throw new Error("decode failed");
    }
  };
  Object.defineProperty(image, "src", {
    set() { queueMicrotask(() => image.onload()); }
  });
  return image;
}

function bindDynamicCreateProjections(plan) {
  plan.data.preview = structuredClone(plan.preview);
  plan.data.parameterPreview = structuredClone(plan.preview);
  return plan;
}

function bindDynamicUpdateProjection(plan) {
  plan.data.preview = structuredClone(plan.preview);
  return plan;
}