xoonya 2.6.0 → 2.7.0

package/scripts/verify_integrations.js

@@ -0,0 +1,170 @@
+"use strict";
+
+const assert = require("assert");
+const stagedPartnerVerifierRegistrationRecord = require("../integrations/examples/example-third-party-verifier-registration.record.json");
+const root = require("../index.js");
+
+async function main() {
+  const integrations = root.listIntegrations();
+  assert.ok(Array.isArray(integrations), "proof integrations list missing");
+  assert.ok(integrations.length >= 4, "proof integration breadth missing");
+  assert.ok(integrations.some((integration) => integration.integration_id === "builtin.identity.legacy_material"), "legacy identity integration missing");
+  assert.ok(integrations.some((integration) => integration.integration_id === "builtin.verifier.registry_profile"), "registry verifier integration missing");
+  assert.ok(integrations.some((integration) => integration.integration_id === stagedPartnerVerifierRegistrationRecord.integration_id), "staged proof verifier integration missing");
+  assert.ok(integrations.some((integration) => integration.certification_state === "certified"), "proof integration certification metadata missing");
+
+  const summary = root.summarizeIntegrations();
+  assert.strictEqual(summary.ok, true, "proof integration summary ok mismatch");
+  assert.ok(summary.integration_count >= integrations.length, "proof integration count mismatch");
+  assert.strictEqual(summary.certified_integration_count >= 5, true, "proof integration certified count mismatch");
+  assert.strictEqual(summary.production_default_count >= 5, true, "proof integration production-default count mismatch");
+  assert.strictEqual(summary.staged_registration_count >= 1, true, "proof integration staged registration count mismatch");
+
+  const detail = root.getIntegration("builtin.verifier.economic_profile");
+  assert.ok(detail, "proof integration detail missing");
+  assert.strictEqual(detail.integration_class, "verification_helper_adapter", "proof integration class mismatch");
+  assert.strictEqual(detail.integration_maturity, "production_default", "proof integration maturity mismatch");
+
+  const bundledFiltered = root.listIntegrations({
+    source: "builtin",
+    certification_state: "certified",
+    integration_maturity: "production_default",
+    bundled: "true"
+  });
+  assert.ok(bundledFiltered.length >= 5, "proof builtin integration filtering mismatch");
+
+  const stagedFiltered = root.listIntegrations({
+    source: "third_party_example",
+    registration_state: "staging_registered",
+    proof_scope: "profile_verification",
+    bundled: "false"
+  });
+  assert.strictEqual(stagedFiltered.length, 1, "proof staged integration filtering mismatch");
+  assert.strictEqual(stagedFiltered[0].registration.requires_explicit_selection, true, "proof staged integration explicit-selection mismatch");
+
+  const validation = root.validateIntegrationRegistration({
+    integration_id: stagedPartnerVerifierRegistrationRecord.integration_id,
+    integration_class: stagedPartnerVerifierRegistrationRecord.integration_class,
+    proof_scope: stagedPartnerVerifierRegistrationRecord.proof_scope
+  }, stagedPartnerVerifierRegistrationRecord);
+  assert.strictEqual(validation.ok, true, "proof integration registration validation failed");
+
+  const imported = root.importRegisteredIntegration({
+    integration_id: "partner.verifier.memory_canary",
+    integration_class: "verification_helper_adapter",
+    display_name: "Memory Canary Verifier",
+    description: "Imported proof-side verifier used to validate normalization.",
+    proof_scope: "profile_verification",
+    capabilities: ["memory_canary.verify"],
+    public_surfaces: ["sdk"],
+    required_inputs: ["profile"],
+    emitted_artifacts: [],
+    verification_targets: ["memory_canary_profile"]
+  }, {
+    integration_id: "partner.verifier.memory_canary",
+    integration_class: "verification_helper_adapter",
+    proof_scope: "profile_verification",
+    registration_state: "local_only",
+    integration_maturity: "reference_example",
+    certification_state: "reference_example",
+    bundled: false,
+    default_selection_enabled: false,
+    requires_explicit_selection: true,
+    registered_at: "2026-03-20T00:00:00Z"
+  }, {
+    source: "verification_import_test",
+    certification_scope: ["contract_shape"],
+    operational_readiness: "reference"
+  });
+  assert.strictEqual(imported.integration_id, "partner.verifier.memory_canary", "proof imported integration id mismatch");
+  assert.strictEqual(imported.registration.registration_state, "local_only", "proof imported integration registration state mismatch");
+
+  const snapshot = root.exportIntegrationRegistrySnapshot({
+    registration_state: "staging_registered"
+  });
+  assert.strictEqual(snapshot.integration_count >= 1, true, "proof integration snapshot count mismatch");
+  assert.strictEqual(root.validateIntegrationRegistrySnapshot(snapshot).ok, true, "proof integration snapshot validation mismatch");
+
+  const builtinPromotion = root.summarizeIntegrationPromotionReadiness("builtin.verifier.registry_profile");
+  assert.strictEqual(builtinPromotion.ok, true, "proof builtin promotion readiness mismatch");
+  assert.strictEqual(builtinPromotion.promotion_readiness.default_eligible, true, "proof builtin default eligibility mismatch");
+  assert.strictEqual(builtinPromotion.promotion_readiness.production_default_ready, true, "proof builtin production-default readiness mismatch");
+
+  const stagedPromotion = root.summarizeIntegrationPromotionReadiness("partner.verifier.lattice_notary");
+  assert.strictEqual(stagedPromotion.ok, true, "proof staged promotion readiness mismatch");
+  assert.strictEqual(stagedPromotion.promotion_readiness.review_ready, true, "proof staged review-ready mismatch");
+  assert.strictEqual(stagedPromotion.promotion_readiness.default_eligible, false, "proof staged default eligibility mismatch");
+  assert.strictEqual(stagedPromotion.promotion_readiness.production_default_ready, false, "proof staged production-default readiness mismatch");
+  assert.ok(stagedPromotion.promotion_readiness.blockers.includes("not_certified"), "proof staged certification blocker missing");
+
+  const builtinPromotionWorkflow = root.summarizeIntegrationPromotionWorkflow("builtin.verifier.registry_profile");
+  assert.strictEqual(builtinPromotionWorkflow.ok, true, "proof builtin promotion workflow mismatch");
+  assert.strictEqual(
+    builtinPromotionWorkflow.next_transition.action,
+    "maintain_production_default",
+    "proof builtin promotion workflow next-transition mismatch"
+  );
+  assert.strictEqual(
+    builtinPromotionWorkflow.promotion_recommendation.recommendation,
+    "eligible_for_production_default",
+    "proof builtin promotion workflow recommendation mismatch"
+  );
+
+  const stagedPromotionWorkflow = root.summarizeIntegrationPromotionWorkflow("partner.verifier.lattice_notary");
+  assert.strictEqual(stagedPromotionWorkflow.ok, true, "proof staged promotion workflow mismatch");
+  assert.strictEqual(
+    stagedPromotionWorkflow.next_transition.action,
+    "complete_certification",
+    "proof staged promotion workflow next-transition mismatch"
+  );
+  assert.strictEqual(
+    stagedPromotionWorkflow.next_transition.later_actions.includes("promote_maturity"),
+    true,
+    "proof staged promotion workflow later-actions mismatch"
+  );
+  assert.strictEqual(
+    stagedPromotionWorkflow.promotion_recommendation.recommendation,
+    "keep_staged_until_requirements_clear",
+    "proof staged promotion workflow recommendation mismatch"
+  );
+  assert.strictEqual(
+    stagedPromotionWorkflow.certification_gaps.missing_requirements.includes("certification_state"),
+    true,
+    "proof staged promotion workflow certification gap mismatch"
+  );
+  assert.strictEqual(
+    stagedPromotionWorkflow.blocker_categories.some((entry) => entry.category === "certification"),
+    true,
+    "proof staged promotion workflow blocker-category mismatch"
+  );
+
+  const promotionWorkflowList = root.summarizeIntegrationPromotionWorkflowList({
+    source: "third_party_example",
+    registration_state: "staging_registered",
+    bundled: "false"
+  });
+  assert.strictEqual(promotionWorkflowList.ok, true, "proof promotion workflow list mismatch");
+  assert.strictEqual(promotionWorkflowList.integration_count >= 1, true, "proof promotion workflow list breadth mismatch");
+  assert.strictEqual(
+    promotionWorkflowList.next_actions.some((entry) => entry.action === "complete_certification"),
+    true,
+    "proof promotion workflow list next-action mismatch"
+  );
+  assert.strictEqual(
+    promotionWorkflowList.recommendations.some((entry) => entry.recommendation === "keep_staged_until_requirements_clear"),
+    true,
+    "proof promotion workflow list recommendation mismatch"
+  );
+  assert.strictEqual(
+    promotionWorkflowList.blocker_categories.some((entry) => entry.category === "certification"),
+    true,
+    "proof promotion workflow list blocker-category mismatch"
+  );
+
+  console.log("xoonya verify:integrations passed");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/scripts/verify_release_candidate.js

@@ -0,0 +1,87 @@
+"use strict";
+
+const assert = require("assert");
+const path = require("path");
+const { execFileSync, execSync } = require("child_process");
+const packageJson = require("../package.json");
+
+function parsePackDryRun() {
+  const output = execSync("npm pack --dry-run --json", {
+    cwd: path.resolve(__dirname, ".."),
+    encoding: "utf8"
+  });
+  const parsed = JSON.parse(output);
+  return Array.isArray(parsed) ? parsed[0] : parsed;
+}
+
+function main() {
+  const releaseOutput = execFileSync(process.execPath, [
+    path.resolve(__dirname, "..", "bin", "xoonya-release.js"),
+    "--candidate",
+    "--summary"
+  ], {
+    cwd: path.resolve(__dirname, ".."),
+    encoding: "utf8"
+  });
+  const releaseCandidate = JSON.parse(releaseOutput);
+  assert.strictEqual(releaseCandidate.product, "xoonya", "release candidate product mismatch");
+  assert.strictEqual(releaseCandidate.publish_access, "public", "release candidate publish access mismatch");
+  assert.strictEqual(releaseCandidate.checklist_count >= 5, true, "release candidate checklist count mismatch");
+
+  const conformanceOutput = execFileSync(process.execPath, [
+    path.resolve(__dirname, "..", "bin", "xoonya.js"),
+    "conformance",
+    "--json"
+  ], {
+    cwd: path.resolve(__dirname, ".."),
+    encoding: "utf8"
+  });
+  const conformanceSummary = JSON.parse(conformanceOutput);
+  assert.strictEqual(conformanceSummary.ok, true, "conformance command did not pass");
+  assert.strictEqual(conformanceSummary.conformance_count >= 8, true, "conformance vector count too small");
+  assert.strictEqual(conformanceSummary.adversarial_count >= 8, true, "adversarial vector count too small");
+  assert.deepStrictEqual(
+    conformanceSummary.verification_methods,
+    [
+      "detached-assertion-v1",
+      "did-vc-v1",
+      "jwt-assertion-v1",
+      "legacy-opreturn-v1",
+      "partner-proof-envelope-v1",
+      "sd-jwt-vc-v1",
+      "signed-envelope-v1",
+      "xoonya-native-anchored-v1",
+      "xoonya-native-sha256-v1",
+      "xoonya-native-signed-v1"
+    ],
+    "conformance methods mismatch"
+  );
+
+  const dryRun = parsePackDryRun();
+  assert.strictEqual(dryRun.name, packageJson.name, "npm pack dry-run name mismatch");
+  assert.strictEqual(dryRun.version, packageJson.version, "npm pack dry-run version mismatch");
+  assert.strictEqual(Array.isArray(dryRun.files), true, "npm pack dry-run file list missing");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "bin/xoonya.js"), true, "npm pack dry-run missing xoonya cli");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "bin/xoonya-first-run.js"), true, "npm pack dry-run missing xoonya-first-run");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "bin/xoonya-review.js"), true, "npm pack dry-run missing xoonya-review");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "bin/xoonya-release.js"), true, "npm pack dry-run missing xoonya-release");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "scripts/verify_vectors.js"), true, "npm pack dry-run missing conformance verifier script");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "scripts/verify_all.js"), true, "npm pack dry-run missing package verifier script");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "vectors/conformance-vectors.json"), true, "npm pack dry-run missing conformance vectors");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "vectors/adversarial-vectors.json"), true, "npm pack dry-run missing adversarial vectors");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "vectors/native-atom-vectors.json"), true, "npm pack dry-run missing native atom vectors");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "README.md"), true, "npm pack dry-run missing README");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "XOONYA_NATIVE_ATOM_SPEC.md"), true, "npm pack dry-run missing native atom spec");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "XOONYA_NATIVE_STANDARD_GOVERNANCE.md"), true, "npm pack dry-run missing native governance doc");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "RELEASE_NOTES.md"), true, "npm pack dry-run missing release notes");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "START_HERE.md"), true, "npm pack dry-run missing start-here");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "SERVICE_CONTRACT.md"), true, "npm pack dry-run missing service contract");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "OPERATOR_START_HERE.md"), false, "npm pack dry-run should not ship operator start-here");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "OPERATIONS_RUNBOOK.md"), false, "npm pack dry-run should not ship operations runbook");
+  assert.strictEqual(dryRun.files.some((entry) => entry.path === "PUBLISH_PLAN.md"), false, "npm pack dry-run should not ship publish plan");
+  assert.strictEqual(dryRun.files.length >= 10, true, "npm pack dry-run file count too small");
+
+  console.log("xoonya verify:release-candidate passed");
+}
+
+main();