xoonya 3.0.0 → 3.1.0

package/scripts/verify_control_plane_contracts.js

@@ -0,0 +1,34 @@
+"use strict";
+
+const assert = require("assert");
+const {
+  summarizeAdapterCertificationContractPack,
+  summarizeTrustPortabilityBoundaryContractPack,
+  summarizeSignedAuditProvenanceContractPack
+} = require("../index.js");
+
+function main() {
+  const adapterCertification = summarizeAdapterCertificationContractPack();
+  const trustPortabilityBoundary = summarizeTrustPortabilityBoundaryContractPack();
+  const signedAuditProvenance = summarizeSignedAuditProvenanceContractPack();
+
+  assert.strictEqual(adapterCertification.ok, true, "adapter certification summary failed");
+  assert.strictEqual(adapterCertification.certification_state_count >= 5, true, "adapter certification state count mismatch");
+  assert.strictEqual(adapterCertification.certification_front_count >= 8, true, "adapter certification front count mismatch");
+  assert.strictEqual(adapterCertification.required_test_category_count >= 8, true, "adapter certification test category count mismatch");
+
+  assert.strictEqual(trustPortabilityBoundary.ok, true, "trust portability boundary summary failed");
+  assert.strictEqual(trustPortabilityBoundary.portable_axis_count >= 4, true, "trust portability axis count mismatch");
+  assert.strictEqual(trustPortabilityBoundary.non_claim_count >= 4, true, "trust portability non-claim count mismatch");
+  assert.strictEqual(trustPortabilityBoundary.evidence_requirement_count >= 5, true, "trust portability evidence requirement count mismatch");
+
+  assert.strictEqual(signedAuditProvenance.ok, true, "signed audit provenance summary failed");
+  assert.strictEqual(signedAuditProvenance.evidence_surface_count >= 6, true, "signed audit provenance surface count mismatch");
+  assert.strictEqual(signedAuditProvenance.required_field_count >= 7, true, "signed audit provenance required field count mismatch");
+  assert.strictEqual(signedAuditProvenance.export_rule_count >= 4, true, "signed audit provenance export rule count mismatch");
+
+  console.log("xoonya verify:control-plane-contracts passed");
+}
+
+main();
+

package/scripts/verify_control_plane_routes.js

@@ -0,0 +1,70 @@
+"use strict";
+
+const assert = require("assert");
+const { createServer } = require("../server.js");
+
+async function getJson(baseUrl, route) {
+  const response = await fetch(`${baseUrl}${route}`);
+  return {
+    status: response.status,
+    json: await response.json()
+  };
+}
+
+async function main() {
+  const server = createServer();
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  const baseUrl = `http://127.0.0.1:${address.port}`;
+
+  try {
+    const adapterCertification = await getJson(baseUrl, "/v1/adapter-certification");
+    assert.strictEqual(adapterCertification.status, 200, "adapter certification route failed");
+    assert.strictEqual(adapterCertification.json.category, "naxytra-adapter-certification-contract", "adapter certification category mismatch");
+    assert.strictEqual(adapterCertification.json.certification_fronts.length >= 8, true, "adapter certification front count mismatch");
+
+    const adapterCertificationSummary = await getJson(baseUrl, "/v1/adapter-certification/summary");
+    assert.strictEqual(adapterCertificationSummary.status, 200, "adapter certification summary route failed");
+    assert.strictEqual(adapterCertificationSummary.json.certification_state_count >= 5, true, "adapter certification summary count mismatch");
+
+    const adapterCertificationDetail = await getJson(baseUrl, "/v1/adapter-certification/protocol_front");
+    assert.strictEqual(adapterCertificationDetail.status, 200, "adapter certification detail route failed");
+    assert.strictEqual(adapterCertificationDetail.json.front.front_id, "protocol_front", "adapter certification detail mismatch");
+
+    const trustBoundary = await getJson(baseUrl, "/v1/trust-portability-boundary");
+    assert.strictEqual(trustBoundary.status, 200, "trust portability boundary route failed");
+    assert.strictEqual(trustBoundary.json.category, "naxytra-trust-portability-boundary-contract", "trust portability boundary category mismatch");
+    assert.strictEqual(trustBoundary.json.portable_axes.length >= 4, true, "trust portability boundary axis count mismatch");
+
+    const trustBoundarySummary = await getJson(baseUrl, "/v1/trust-portability-boundary/summary");
+    assert.strictEqual(trustBoundarySummary.status, 200, "trust portability boundary summary route failed");
+    assert.strictEqual(trustBoundarySummary.json.portable_axis_count >= 4, true, "trust portability boundary summary count mismatch");
+
+    const trustBoundaryDetail = await getJson(baseUrl, "/v1/trust-portability-boundary/agent_identity_portability");
+    assert.strictEqual(trustBoundaryDetail.status, 200, "trust portability boundary detail route failed");
+    assert.strictEqual(trustBoundaryDetail.json.axis.axis_id, "agent_identity_portability", "trust portability boundary detail mismatch");
+
+    const signedAudit = await getJson(baseUrl, "/v1/signed-audit-provenance");
+    assert.strictEqual(signedAudit.status, 200, "signed audit provenance route failed");
+    assert.strictEqual(signedAudit.json.category, "naxytra-signed-audit-provenance-contract", "signed audit provenance category mismatch");
+    assert.strictEqual(signedAudit.json.evidence_surfaces.length >= 6, true, "signed audit provenance evidence surface count mismatch");
+
+    const signedAuditSummary = await getJson(baseUrl, "/v1/signed-audit-provenance/summary");
+    assert.strictEqual(signedAuditSummary.status, 200, "signed audit provenance summary route failed");
+    assert.strictEqual(signedAuditSummary.json.evidence_surface_count >= 6, true, "signed audit provenance summary count mismatch");
+
+    const signedAuditDetail = await getJson(baseUrl, "/v1/signed-audit-provenance/release_provenance");
+    assert.strictEqual(signedAuditDetail.status, 200, "signed audit provenance detail route failed");
+    assert.strictEqual(signedAuditDetail.json.surface.surface_id, "release_provenance", "signed audit provenance detail mismatch");
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+  }
+
+  console.log("xoonya verify:control-plane-routes passed");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});
+

package/scripts/verify_examples.js

@@ -1,19 +1,19 @@
-"use strict";
-
-const { spawnSync } = require("child_process");
-const path = require("path");
-
-function runExample(scriptPath) {
-  const result = spawnSync(process.execPath, [scriptPath], {
-    stdio: "inherit"
-  });
-  if (result.status !== 0) {
-    process.exit(result.status || 1);
-  }
-}
-
-runExample(path.join(__dirname, "..", "examples", "package_quickstart.js"));
-runExample(path.join(__dirname, "..", "examples", "review_carried_handoff.js"));
-runExample(path.join(__dirname, "..", "examples", "partner_proof_walkthrough.js"));
-runExample(path.join(__dirname, "..", "examples", "proof_review_walkthrough.js"));
-runExample(path.join(__dirname, "..", "examples", "integration_boundary_walkthrough.js"));
+"use strict";
+
+const { spawnSync } = require("child_process");
+const path = require("path");
+
+function runExample(scriptPath) {
+  const result = spawnSync(process.execPath, [scriptPath], {
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    process.exit(result.status || 1);
+  }
+}
+
+runExample(path.join(__dirname, "..", "examples", "package_quickstart.js"));
+runExample(path.join(__dirname, "..", "examples", "review_carried_handoff.js"));
+runExample(path.join(__dirname, "..", "examples", "partner_proof_walkthrough.js"));
+runExample(path.join(__dirname, "..", "examples", "proof_review_walkthrough.js"));
+runExample(path.join(__dirname, "..", "examples", "integration_boundary_walkthrough.js"));

package/scripts/verify_external_proof_import_gate.js

@@ -1,84 +1,84 @@
-"use strict";
-
-const assert = require("assert");
-const {
-  buildExternalProofImportAdapterPack,
-  validateExternalProofImportEvidence
-} = require("../proof_sdk");
-
-function validImport() {
-  return {
-    method: "jwt-assertion-v1",
-    import_ref: "external-import-gate-demo",
-    issuer_ref: "did:example:issuer",
-    subject_ref: "txn:xytara:demo",
-    external_proof: "eyJhbGciOiJFZERTQSJ9.eyJzdWIiOiJ0eG4teHl0YXJhLWRlbW8ifQ.signature",
-    evidence_refs: ["memory://external/import-gate-demo"]
-  };
-}
-
-function assertRejected(input, expectedCode) {
-  const validation = validateExternalProofImportEvidence(input);
-  assert.strictEqual(validation.import_allowed, false, `expected ${expectedCode} to block external proof import`);
-  assert.strictEqual(
-    validation.rejection_codes.includes(expectedCode),
-    true,
-    `missing deterministic rejection code ${expectedCode}`
-  );
-  return validation;
-}
-
-function main() {
-  const pack = buildExternalProofImportAdapterPack();
-  const validValidation = validateExternalProofImportEvidence(validImport());
-
-  assert.strictEqual(pack.category, "xoonya-external-proof-import-adapter", "external import adapter category mismatch");
-  assert.strictEqual(pack.deterministic_rejection_codes.length >= 11, true, "external import rejection code count missing");
-  assert.strictEqual(validValidation.import_allowed, true, "valid structural external import should pass");
-  assert.deepStrictEqual(validValidation.rejection_codes, [], "valid structural external import should not carry rejection codes");
-
-  assertRejected({ ...validImport(), method: "" }, "verification_method_required");
-  assertRejected({ ...validImport(), method: "unknown-method-v1" }, "verification_method_unsupported");
-  assertRejected({ ...validImport(), method: "xoonya-native-sha256-v1" }, "verification_method_not_external_importable");
-  assertRejected({ method: "jwt-assertion-v1" }, "external_proof_material_required");
-  assertRejected({ ...validImport(), external_proof: "   " }, "external_proof_material_empty");
-  assertRejected({ ...validImport(), declared_hash_sha256: "00".repeat(32) }, "external_proof_hash_mismatch");
-  assertRejected({ ...validImport(), claim_external_issuer_truth: true }, "external_issuer_truth_claim_requires_external_verifier");
-  assertRejected({ ...validImport(), claim_external_signature_truth: true }, "external_signature_truth_claim_requires_external_verifier");
-  assertRejected({ ...validImport(), claim_external_revocation_status: true }, "external_revocation_status_claim_requires_external_verifier");
-  assertRejected({ ...validImport(), method: "did-vc-v1", claim_did_resolution_truth: true }, "did_resolution_truth_claim_requires_external_verifier");
-  assertRejected({ ...validImport(), external_verifier_api_key: "sk_live_accidental_secret" }, "secret_material_forbidden");
-
-  const externallyVerified = validateExternalProofImportEvidence({
-    ...validImport(),
-    method: "did-vc-v1",
-    external_proof: {
-      "@context": ["https://www.w3.org/ns/credentials/v2"],
-      type: ["VerifiableCredential"],
-      issuer: "did:example:issuer",
-      credentialSubject: { id: "did:example:agent" }
-    },
-    claim_external_issuer_truth: true,
-    claim_external_signature_truth: true,
-    claim_external_revocation_status: true,
-    claim_did_resolution_truth: true,
-    external_issuer_verifier_ref: "external.verifier.issuer.did-vc.2026-04-22",
-    external_signature_verifier_ref: "external.verifier.signature.did-vc.2026-04-22",
-    external_revocation_verifier_ref: "external.verifier.revocation.did-vc.2026-04-22",
-    did_resolution_verifier_ref: "external.verifier.did_resolution.did-vc.2026-04-22"
-  });
-  assert.strictEqual(externallyVerified.import_allowed, true, "external verifier-backed truth claims should pass structural validation");
-
-  const output = {
-    ok: true,
-    product: "xoonya",
-    category: "xoonya-external-proof-import-gate-verification",
-    status: "external_import_binds_evidence_without_claiming_external_truth_unless_external_verifier_refs_exist",
-    deterministic_rejection_code_count: pack.deterministic_rejection_codes.length,
-    adversarial_case_count: 11,
-    boundary: "xoonya_imports_external_evidence_but_external_issuer_signature_revocation_and_did_truth_stay_with_external_verifiers"
-  };
-  process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
-}
-
-main();
+"use strict";
+
+const assert = require("assert");
+const {
+  buildExternalProofImportAdapterPack,
+  validateExternalProofImportEvidence
+} = require("../proof_sdk");
+
+function validImport() {
+  return {
+    method: "jwt-assertion-v1",
+    import_ref: "external-import-gate-demo",
+    issuer_ref: "did:example:issuer",
+    subject_ref: "txn:xytara:demo",
+    external_proof: "eyJhbGciOiJFZERTQSJ9.eyJzdWIiOiJ0eG4teHl0YXJhLWRlbW8ifQ.signature",
+    evidence_refs: ["memory://external/import-gate-demo"]
+  };
+}
+
+function assertRejected(input, expectedCode) {
+  const validation = validateExternalProofImportEvidence(input);
+  assert.strictEqual(validation.import_allowed, false, `expected ${expectedCode} to block external proof import`);
+  assert.strictEqual(
+    validation.rejection_codes.includes(expectedCode),
+    true,
+    `missing deterministic rejection code ${expectedCode}`
+  );
+  return validation;
+}
+
+function main() {
+  const pack = buildExternalProofImportAdapterPack();
+  const validValidation = validateExternalProofImportEvidence(validImport());
+
+  assert.strictEqual(pack.category, "xoonya-external-proof-import-adapter", "external import adapter category mismatch");
+  assert.strictEqual(pack.deterministic_rejection_codes.length >= 11, true, "external import rejection code count missing");
+  assert.strictEqual(validValidation.import_allowed, true, "valid structural external import should pass");
+  assert.deepStrictEqual(validValidation.rejection_codes, [], "valid structural external import should not carry rejection codes");
+
+  assertRejected({ ...validImport(), method: "" }, "verification_method_required");
+  assertRejected({ ...validImport(), method: "unknown-method-v1" }, "verification_method_unsupported");
+  assertRejected({ ...validImport(), method: "xoonya-native-sha256-v1" }, "verification_method_not_external_importable");
+  assertRejected({ method: "jwt-assertion-v1" }, "external_proof_material_required");
+  assertRejected({ ...validImport(), external_proof: "   " }, "external_proof_material_empty");
+  assertRejected({ ...validImport(), declared_hash_sha256: "00".repeat(32) }, "external_proof_hash_mismatch");
+  assertRejected({ ...validImport(), claim_external_issuer_truth: true }, "external_issuer_truth_claim_requires_external_verifier");
+  assertRejected({ ...validImport(), claim_external_signature_truth: true }, "external_signature_truth_claim_requires_external_verifier");
+  assertRejected({ ...validImport(), claim_external_revocation_status: true }, "external_revocation_status_claim_requires_external_verifier");
+  assertRejected({ ...validImport(), method: "did-vc-v1", claim_did_resolution_truth: true }, "did_resolution_truth_claim_requires_external_verifier");
+  assertRejected({ ...validImport(), external_verifier_api_key: "sk_live_accidental_secret" }, "secret_material_forbidden");
+
+  const externallyVerified = validateExternalProofImportEvidence({
+    ...validImport(),
+    method: "did-vc-v1",
+    external_proof: {
+      "@context": ["https://www.w3.org/ns/credentials/v2"],
+      type: ["VerifiableCredential"],
+      issuer: "did:example:issuer",
+      credentialSubject: { id: "did:example:agent" }
+    },
+    claim_external_issuer_truth: true,
+    claim_external_signature_truth: true,
+    claim_external_revocation_status: true,
+    claim_did_resolution_truth: true,
+    external_issuer_verifier_ref: "external.verifier.issuer.did-vc.2026-04-22",
+    external_signature_verifier_ref: "external.verifier.signature.did-vc.2026-04-22",
+    external_revocation_verifier_ref: "external.verifier.revocation.did-vc.2026-04-22",
+    did_resolution_verifier_ref: "external.verifier.did_resolution.did-vc.2026-04-22"
+  });
+  assert.strictEqual(externallyVerified.import_allowed, true, "external verifier-backed truth claims should pass structural validation");
+
+  const output = {
+    ok: true,
+    product: "xoonya",
+    category: "xoonya-external-proof-import-gate-verification",
+    status: "external_import_binds_evidence_without_claiming_external_truth_unless_external_verifier_refs_exist",
+    deterministic_rejection_code_count: pack.deterministic_rejection_codes.length,
+    adversarial_case_count: 11,
+    boundary: "xoonya_imports_external_evidence_but_external_issuer_signature_revocation_and_did_truth_stay_with_external_verifiers"
+  };
+  process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+}
+
+main();