feat(device-plane): add universal adapter acceptance boundary

device-plane/packages/device-protocol-contract/test/contract.test.mjs

@@ -2,16 +2,23 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import {
+  DEVICE_ADAPTER_ACCEPTANCE_SCHEMA,
+  DEVICE_ADAPTER_MESSAGE_SCHEMA,
   DEVICE_DISCOVERY_SIGNAL_SCHEMA,
   DEVICE_PLANE_BINDING_SCHEMA,
   assertIdentifierDigest,
   assertSafeProjection,
   hashRestrictedIdentifier,
+  maskRestrictedIdentifier,
   normalizeDevicePlaneBinding,
+  normalizeAdapterAcceptance,
+  normalizeAdapterMessage,
   normalizeDiscoverySignal,
+  normalizeRestrictedIdentifier,
   normalizeRestrictedIdentifierProjection,
   normalizeRestrictedIdentifierRecord,
   toSafeDiscoveryView,
+  toSafeAdapterMessageView,
 } from "../src/index.mjs";
 
 const fakeImei = "000000000000001";
@@ -110,6 +117,25 @@ test("restricted identifier records keep digest internal and expose only a mask"
   );
 });
 
+test("restricted identifiers support future adapter-defined hardware ids", () => {
+  const identifier = normalizeRestrictedIdentifier({
+    kind: "serial",
+    value: "SN-TRACKER-0001",
+  });
+  assert.deepEqual(identifier, {
+    kind: "serial",
+    value: "SN-TRACKER-0001",
+  });
+  assert.equal(maskRestrictedIdentifier(identifier), "***********0001");
+  assert.match(
+    hashRestrictedIdentifier(
+      identifier,
+      "test-only-pepper-with-at-least-32-bytes",
+    ),
+    /^hmac-sha256:[a-f0-9]{64}$/,
+  );
+});
+
 test("rejects unverified framing and command-shaped discovery input", () => {
   assert.throws(
     () => normalizeDiscoverySignal({
@@ -147,3 +173,93 @@ test("normalizes an opaque Foundry control binding without device data", () => {
   assert.deepEqual(binding.capabilities, ["inspect", "observe"]);
   assertSafeProjection(binding);
 });
+
+test("normalizes a bounded typed adapter message and masks its identity", () => {
+  const message = {
+    schemaVersion: DEVICE_ADAPTER_MESSAGE_SCHEMA,
+    edgeRef: "edge:robot2b-vps-001",
+    adapterRef: "arusnavi-b2",
+    protocolProfileRef: "arusnavi.b2.internal.v1",
+    protocol: "INTERNAL",
+    sessionRef: "session:test-001",
+    routeRef: "route:11111111-1111-4111-8111-111111111111",
+    messageRef: "package:1:abc123",
+    messageType: "telemetry.package",
+    sequence: 1,
+    observedAt: "2026-08-11T12:00:00.000Z",
+    idempotencyKey: `sha256:${"a".repeat(64)}`,
+    identifier: { kind: "imei", value: fakeImei },
+    payloadSchemaRef: "arusnavi.internal.package-metadata.v1",
+    payload: {
+      packageNumber: 1,
+      packetCount: 1,
+      packageDigest: `sha256:${"b".repeat(64)}`,
+    },
+  };
+  const normalized = normalizeAdapterMessage(message);
+  const safe = toSafeAdapterMessageView(normalized);
+  assert.equal(normalized.identifier.value, fakeImei);
+  assert.equal(safe.identifier.masked, "***********0001");
+  assert.equal(JSON.stringify(safe).includes(fakeImei), false);
+  assertSafeProjection(safe);
+});
+
+test("rejects oversized, untyped and secret-shaped adapter messages", () => {
+  const base = {
+    schemaVersion: DEVICE_ADAPTER_MESSAGE_SCHEMA,
+    edgeRef: "edge:test",
+    adapterRef: "generic-tracker",
+    protocolProfileRef: "generic.tracker.v1",
+    protocol: "GENERIC",
+    sessionRef: "session:test",
+    messageRef: "message:1",
+    messageType: "telemetry.sample",
+    sequence: 1,
+    observedAt: "2026-08-11T12:00:00.000Z",
+    idempotencyKey: `sha256:${"a".repeat(64)}`,
+    identifier: { kind: "imei", value: fakeImei },
+    payloadSchemaRef: "generic.telemetry.v1",
+    payload: { value: 1 },
+  };
+  assert.throws(
+    () => normalizeAdapterMessage({ ...base, payload: "raw" }),
+    /device_adapter_message_payload_invalid/,
+  );
+  assert.throws(
+    () => normalizeAdapterMessage({
+      ...base,
+      payload: { devicePassword: "forbidden" },
+    }),
+    /forbidden_device_field/,
+  );
+  assert.throws(
+    () => normalizeAdapterMessage({
+      ...base,
+      payload: { value: "x".repeat(4096) },
+    }, { maxBytes: 1024 }),
+    /device_adapter_message_too_large/,
+  );
+  assert.throws(
+    () => normalizeAdapterMessage({
+      ...base,
+      idempotencyKey: "message-not-a-digest",
+    }),
+    /idempotency_key_invalid/,
+  );
+});
+
+test("accepts only an explicit durable Core acceptance contract", () => {
+  const acceptance = normalizeAdapterAcceptance({
+    schemaVersion: DEVICE_ADAPTER_ACCEPTANCE_SCHEMA,
+    acceptanceRef: "acceptance:test-001",
+    idempotencyKey: `sha256:${"a".repeat(64)}`,
+    status: "accepted",
+    replayed: false,
+    acceptedAt: "2026-08-11T12:00:00.000Z",
+  });
+  assert.equal(acceptance.status, "accepted");
+  assert.throws(
+    () => normalizeAdapterAcceptance({ ...acceptance, status: "queued" }),
+    /device_adapter_acceptance_status_invalid/,
+  );
+});