xoonya 1.27.0 → 2.1.0

package/lib/outreach_proof.js

@@ -0,0 +1,71 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildOutreachProofPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-outreach-proof",
+    proven_live_today: [
+      "carried runtime handoff review with economic and settlement carry",
+      "proof-side review path aligned with real runtime and settlement evidence",
+      "handoff and governance surfaces exposed for operator inspection",
+      "portable proof-bundle contract packaged for public release posture"
+    ],
+    live_rails: [
+      {
+        rail_ref: "carried_handoff_review",
+        status: "proven_live",
+        trust_signal: "runtime output can be reviewed as proof-side intake rather than opaque logs"
+      },
+      {
+        rail_ref: "proof_center_followthrough",
+        status: "launch_ready",
+        trust_signal: "default proof loops, governance surfaces, and result-package followthrough are publicly exposed"
+      },
+      {
+        rail_ref: "economic_and_settlement_carry",
+        status: "proven_live",
+        trust_signal: "settlement and economic refs survive into proof-side review summaries"
+      }
+    ],
+    credible_public_proof_path: {
+      path_ref: "scenario.carried_handoff.review",
+      why_credible: "smallest public run that matches the already-demonstrated runtime-to-proof carry and review posture",
+      cli: "xoonya-review --file ./handoff.json --summary"
+    },
+    trust_today_vs_later: {
+      trust_today: [
+        "proof-side review for carried handoff bundles",
+        "handoff and governance inspection surfaces",
+        "portable proof-bundle contract",
+        "runtime-to-proof continuation posture"
+      ],
+      later_depth: [
+        "broader third-party runtime adoption after release",
+        "expanded proof ecosystem integrations after public package launch",
+        "continued release-line expansion after public proof-spine adoption"
+      ]
+    }
+  };
+}
+
+function summarizeOutreachProofPack() {
+  const pack = buildOutreachProofPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    proven_count: pack.proven_live_today.length,
+    live_rail_count: pack.live_rails.length,
+    trust_today_count: pack.trust_today_vs_later.trust_today.length,
+    later_depth_count: pack.trust_today_vs_later.later_depth.length,
+    first_path_ref: pack.credible_public_proof_path.path_ref
+  };
+}
+
+module.exports = {
+  buildOutreachProofPack,
+  summarizeOutreachProofPack
+};

package/lib/publish_plan.js

@@ -0,0 +1,51 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildPublishPlan() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-publish-plan",
+    version: packageJson.version,
+    commands: {
+      verify_release_candidate: "npm run verify:release-candidate",
+      pack_dry_run: "npm pack --dry-run --json",
+      publish: "npm publish --access public",
+      release_cli_check: "xoonya-release --candidate --summary"
+    },
+    live_checks: [
+      "/v1/release-candidate/summary",
+      "/v1/release-center/summary",
+      "/v1/announcement-pack/summary",
+      "/v1/outreach-proof/summary"
+    ],
+    publish_sequence: [
+      "run the release-candidate verification",
+      "confirm the dry-run package contents",
+      "publish the npm package at public access",
+      "redeploy the live service surfaces",
+      "verify the release-candidate and release-center summaries live",
+      "run the first public proof-side review path"
+    ]
+  };
+}
+
+function summarizePublishPlan() {
+  const plan = buildPublishPlan();
+  return {
+    ok: true,
+    product: plan.product,
+    category: plan.category,
+    version: plan.version,
+    command_count: Object.keys(plan.commands).length,
+    live_check_count: plan.live_checks.length,
+    publish_step_count: plan.publish_sequence.length,
+    publish_command: plan.commands.publish
+  };
+}
+
+module.exports = {
+  buildPublishPlan,
+  summarizePublishPlan
+};

package/lib/release_candidate.js

@@ -0,0 +1,50 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildReleaseCandidatePack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-release-candidate",
+    version: packageJson.version,
+    package_posture: {
+      publish_access: packageJson.publishConfig && packageJson.publishConfig.access ? packageJson.publishConfig.access : null,
+      engine: packageJson.engines && packageJson.engines.node ? packageJson.engines.node : null,
+      bin_count: Object.keys(packageJson.bin || {}).length,
+      published_file_count: Array.isArray(packageJson.files) ? packageJson.files.length : 0
+    },
+    rehearsal: {
+      clean_install_command: "npm install xoonya",
+      dry_run_pack_command: "npm pack --dry-run --json",
+      release_check_command: "npm run verify:release-candidate",
+      first_release_view: "xoonya-release --candidate --summary"
+    },
+    checklist: [
+      "run npm run verify:release-candidate",
+      "confirm npm pack --dry-run includes public docs and bin entrypoints",
+      "confirm release-center and announcement-pack summaries are live after deploy",
+      "confirm the first public proof-side review path still succeeds",
+      "only then proceed to npm publish"
+    ]
+  };
+}
+
+function summarizeReleaseCandidatePack() {
+  const pack = buildReleaseCandidatePack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    version: pack.version,
+    publish_access: pack.package_posture.publish_access,
+    bin_count: pack.package_posture.bin_count,
+    published_file_count: pack.package_posture.published_file_count,
+    checklist_count: pack.checklist.length
+  };
+}
+
+module.exports = {
+  buildReleaseCandidatePack,
+  summarizeReleaseCandidatePack
+};

package/lib/release_center.js

@@ -0,0 +1,113 @@
+"use strict";
+
+const {
+  summarizeReleasePack,
+  summarizeComparisonPack,
+  summarizeAdoptionPack,
+  summarizeScenarioPack,
+  summarizeLaunchPack
+} = require("./release_pack");
+const {
+  summarizeReleaseManifest,
+  summarizeLaunchNotes
+} = require("./release_manifest");
+const {
+  summarizeReleaseHistory
+} = require("./release_history");
+const {
+  summarizePublishPlan
+} = require("./publish_plan");
+const {
+  summarizeEcosystemEntryPack
+} = require("./ecosystem_entry");
+const {
+  summarizeLaunchNarrativePack
+} = require("./launch_narrative");
+const {
+  summarizeOutreachProofPack
+} = require("./outreach_proof");
+const {
+  summarizeAnnouncementPack
+} = require("./announcement_pack");
+const {
+  summarizeReleaseCandidatePack
+} = require("./release_candidate");
+
+function buildReleaseCenter() {
+  return {
+    ok: true,
+    product: "xoonya",
+    category: "proof-release-center",
+    center: {
+      release_summary: summarizeReleasePack(),
+      comparison_summary: summarizeComparisonPack(),
+      adoption_summary: summarizeAdoptionPack(),
+      scenario_summary: summarizeScenarioPack(),
+      launch_summary: summarizeLaunchPack(),
+      manifest_summary: summarizeReleaseManifest(),
+      notes_summary: summarizeLaunchNotes(),
+      history_summary: summarizeReleaseHistory(),
+      publish_plan_summary: summarizePublishPlan(),
+      ecosystem_entry_summary: summarizeEcosystemEntryPack(),
+      launch_narrative_summary: summarizeLaunchNarrativePack(),
+      outreach_proof_summary: summarizeOutreachProofPack(),
+      announcement_summary: summarizeAnnouncementPack(),
+      release_candidate_summary: summarizeReleaseCandidatePack()
+    },
+    quickstart: {
+      first_http_entrypoint: "/v1/release-pack/launch/summary",
+      first_cli_entrypoint: "xoonya-release --center --summary",
+      first_run_cli: "xoonya-review --file ./handoff.json --summary",
+      first_docs: [
+        "START_HERE.md",
+        "FINAL_CONTRACT.md",
+        "SERVICE_CONTRACT.md",
+        "RELEASE_NOTES.md"
+      ]
+    },
+    release_surfaces: {
+      release_pack_summary: "/v1/release-pack/summary",
+      launch_summary: "/v1/release-pack/launch/summary",
+      comparison_summary: "/v1/release-pack/comparison/summary",
+      adoption_summary: "/v1/release-pack/adoption/summary",
+      scenario_summary: "/v1/release-pack/scenarios/summary",
+      manifest_summary: "/v1/release-manifest/summary",
+      notes_summary: "/v1/release-notes/summary",
+      history_summary: "/v1/release-history/summary",
+      publish_plan_summary: "/v1/publish-plan/summary",
+      ecosystem_entry_summary: "/v1/ecosystem-entry/summary",
+      launch_narrative_summary: "/v1/launch-narrative/summary",
+      outreach_proof_summary: "/v1/outreach-proof/summary",
+      announcement_summary: "/v1/announcement-pack/summary",
+      release_candidate_summary: "/v1/release-candidate/summary"
+    }
+  };
+}
+
+function summarizeReleaseCenter() {
+  const center = buildReleaseCenter();
+  return {
+    ok: true,
+    product: center.product,
+    category: center.category,
+    integration_count: center.center.release_summary.integration_count,
+    comparison_count: center.center.comparison_summary.comparison_count,
+    target_count: center.center.adoption_summary.target_count,
+    scenario_count: center.center.scenario_summary.scenario_count,
+    verification_surface_count: center.center.manifest_summary.verification_surface_count,
+    operator_check_count: center.center.notes_summary.operator_check_count,
+    release_count: center.center.history_summary.release_count,
+    publish_step_count: center.center.publish_plan_summary.publish_step_count,
+    audience_count: center.center.ecosystem_entry_summary.audience_count,
+    success_signal_count: center.center.launch_narrative_summary.success_signal_count,
+    proven_count: center.center.outreach_proof_summary.proven_count,
+    rc_check_count: center.center.announcement_summary.rc_check_count,
+    candidate_checklist_count: center.center.release_candidate_summary.checklist_count,
+    proof_bundle_version: center.center.release_summary.proof_bundle_version
+  };
+}
+
+module.exports = {
+  buildReleaseCenter,
+  summarizeReleaseCenter
+};

package/lib/release_history.js

@@ -0,0 +1,72 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildReleaseHistory() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-release-history",
+    current_version: packageJson.version,
+    release_track: "public_release",
+    history: [
+      {
+        version: "2.1.0",
+        channel: "public_release",
+        maturity_posture: "launch_ready",
+        headline: "public proof-spine release-candidate with release-center, announcement, and candidate rehearsal surfaces",
+        milestone_refs: [
+          "proof_bundle_contract",
+          "bridge_and_governance_surfaces",
+          "review_cli",
+          "release_pack_surfaces",
+          "release_center_surfaces",
+          "announcement_pack_surfaces",
+          "release_candidate_surfaces"
+        ]
+      },
+      {
+        version: "2.0.0",
+        channel: "public_release",
+        maturity_posture: "launch_ready",
+        headline: "public proof-spine release with direct review, proof launch packaging, and release center surfaces",
+        milestone_refs: [
+          "proof_bundle_contract",
+          "bridge_and_governance_surfaces",
+          "review_cli",
+          "release_pack_surfaces",
+          "release_center_surfaces"
+        ]
+      },
+      {
+        version: "1.x",
+        channel: "pre_public_foundation",
+        maturity_posture: "foundation_building",
+        headline: "pre-public proof contract, verification, and integration groundwork",
+        milestone_refs: [
+          "canonical_event_contract",
+          "verification_helpers",
+          "proof_registry_foundations"
+        ]
+      }
+    ]
+  };
+}
+
+function summarizeReleaseHistory() {
+  const history = buildReleaseHistory();
+  return {
+    ok: true,
+    product: history.product,
+    category: history.category,
+    current_version: history.current_version,
+    release_count: history.history.length,
+    latest_channel: history.history[0].channel,
+    latest_maturity_posture: history.history[0].maturity_posture
+  };
+}
+
+module.exports = {
+  buildReleaseHistory,
+  summarizeReleaseHistory
+};

package/lib/release_manifest.js

@@ -0,0 +1,114 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildReleaseManifest() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    version: packageJson.version,
+    release_track: "public_release",
+    package: {
+      name: packageJson.name,
+      version: packageJson.version,
+      description: packageJson.description,
+      license: packageJson.license,
+      homepage: packageJson.homepage,
+      repository: packageJson.repository && packageJson.repository.url ? packageJson.repository.url : null
+    },
+    install: {
+      install_command: "npm install xoonya",
+      engine: packageJson.engines && packageJson.engines.node ? packageJson.engines.node : null,
+      start_command: "npm start",
+      verify_command: "npm run verify:all"
+    },
+    package_entrypoints: {
+      main: packageJson.main,
+      bin: packageJson.bin || {}
+    },
+    published_files: Array.isArray(packageJson.files) ? packageJson.files.slice() : [],
+    verification_surfaces: [
+      "verify:package",
+      "verify:integrations",
+      "verify:tooling",
+      "verify:vectors",
+      "verify:examples",
+      "verify:service"
+    ],
+    public_contract_docs: [
+      "README.md",
+      "START_HERE.md",
+      "RELEASE_CHECKLIST.md",
+      "FINAL_CONTRACT.md",
+      "SERVICE_CONTRACT.md",
+      "CROSS_RUNTIME_POSTURE.md",
+      "COMPATIBILITY_NOTE.md"
+    ]
+  };
+}
+
+function summarizeReleaseManifest() {
+  const manifest = buildReleaseManifest();
+  return {
+    ok: true,
+    product: manifest.product,
+    version: manifest.version,
+    release_track: manifest.release_track,
+    published_file_count: manifest.published_files.length,
+    verification_surface_count: manifest.verification_surfaces.length,
+    doc_count: manifest.public_contract_docs.length,
+    bin_count: Object.keys(manifest.package_entrypoints.bin || {}).length
+  };
+}
+
+function buildLaunchNotes() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    version: packageJson.version,
+    release_notes: {
+      release_theme: "proof-side machine contract with release-candidate rehearsal, reviewable handoff, and launch-ready proof posture",
+      headline_capabilities: [
+        "one-line proof-side review cli",
+        "release, comparison, adoption, scenario, and launch packs",
+        "announcement, release-center, and release-candidate surfaces",
+        "canonical event, receipt, and proof bundle model",
+        "bridge and governance surfaces for operator trust",
+        "stable runtime-to-proof followthrough"
+      ],
+      strongest_public_claims: [
+        "deterministic proof contract independent of runtime churn",
+        "reviewable handoff before proof-native continuation",
+        "portable proof bundles instead of opaque machine logs",
+        "bridge and governance posture for real operator review"
+      ],
+      operator_checks_before_launch: [
+        "verify all package checks pass",
+        "verify release-candidate rehearsal passes",
+        "verify release-pack launch summary is reachable",
+        "verify proof-center summary is healthy",
+        "verify bridge summary is healthy",
+        "verify first-run scenarios remain accurate"
+      ]
+    }
+  };
+}
+
+function summarizeLaunchNotes() {
+  const notes = buildLaunchNotes();
+  return {
+    ok: true,
+    product: notes.product,
+    version: notes.version,
+    headline_capability_count: notes.release_notes.headline_capabilities.length,
+    claim_count: notes.release_notes.strongest_public_claims.length,
+    operator_check_count: notes.release_notes.operator_checks_before_launch.length
+  };
+}
+
+module.exports = {
+  buildReleaseManifest,
+  summarizeReleaseManifest,
+  buildLaunchNotes,
+  summarizeLaunchNotes
+};