---

🌐 PAXECT — The Universal Deterministic Bridge

Build once, run anywhere.
Connect all operating systems and programming languages through one reproducible, offline-first runtime.

🔗 Learn more about the ecosystem:
👉 PAXECT Universal Bridge ›

---

Looking for the full bundle (Core + plugins + demos)?
See PAXECT Core Complete →

---

🔗 PAXECT Link — Deterministic Inbox/Outbox Bridge

Status: v1.0.0 — Initial Public Release — October 22, 2025

" Deterministic, offline-first, and reproducible — built for secure data pipelines and NIS2-ready digital hygiene.”

Secure, deterministic file relay across processes, runtimes, and operating systems — fully offline. The PAXECT Link Plugin provides a reproducible, verifiable bridge by auto-encoding non-.freq files to .freq and auto-decoding .freq containers to raw files, powered by PAXECT Core.

Plug-and-play with zero dependencies and no vendor lock-in.

No cloud, no AI heuristics — just byte-for-byte deterministic transport.

---

🧩 Overview

PAXECT Link is a shared-folder bridge enabling lossless and reproducible file exchange between heterogeneous systems. It ensures that binary and textual data remain bit-identical when transferred across languages, platforms, and operating systems.

Unlike ad-hoc watchers or fragile serialization layers, Link uses the PAXECT Core container format with CRC32 + SHA-256 to guarantee checksum-verified integrity and perfect reproducibility.

It serves as the glue between analytical systems, edge devices, and enterprise runtimes — enabling deterministic exchange without sockets or servers.

---

⚙️ Key Features

• 🔄 Deterministic Relay — auto-encode non-.freq → .freq, auto-decode .freq → files
• 🔐 Integrity-Checked Transport — CRC32 per frame + SHA-256 footer verification
• 🧠 No-AI / No-Heuristics Policy — deterministic, auditable behavior
• 🧰 Self-Contained — Link is stdlib-only; Core is a single Python CLI
• 💻 Cross-OS Reproducibility — identical output on Linux · macOS · Windows
• 🛡️ Policy Enforcement — trusted nodes, allowed suffixes, max file size
• ✍️ HMAC-Trusted Manifests (optional) — require_sig=true for peer discovery
• 💥 Crash-Safe I/O — atomic .part → fsync → rename, single-instance lock

---

🌍 Supported Languages & Platforms

Operating Systems

Supported	Architecture
Linux (Ubuntu, Debian, Fedora)	x86_64, ARMv8
Windows 10/11	x86_64
macOS 13+ (Intel & Apple Silicon)	arm64, x86_64
FreeBSD / OpenBSD	Experimental
RISC-V	Planned

Languages

Tier	Runtimes
Official	Python (Link + Core)
Also Tested	Shell scripts, Node.js, Go, Rust, Java, C/C++, Swift (via Core CLI piping where needed)

---

🧠 Core Capabilities

Capability	Description
Deterministic Encoding	Bit-identical PAXECT containers across platforms
Secure Hash Validation	CRC32 per frame + SHA-256 of original data
Cross-Runtime Adaptability	Works via stdin/stdout piping with any runtime
Containerized Protocol	Fixed header/footer; multi-channel frames (Core)
Offline Operation	No network or telemetry; local-only

---

🚀 Demos Included

All demos are deterministic, self-contained, and safe to run locally or in CI.

Demo	Script	Description	Status
01	demo_1_local_basic.py	Local encode→decode sanity check	✅
02	demo_2_policy_hmac.py	Policy with HMAC: accept signed, reject unsigned	✅
03	demo_3_multi_node.py	Two Link nodes, per-node lock, both decode	✅
04	demo_4_observability.py	JSONL logs → simple metrics summary	✅
05	demo_5_ci_cd_pipeline.py	CI smoke; emits JUnit XML	✅
06	demo_6_fail_and_recover.py	Simulated failure & automatic recovery (resilience test)	✅

Run all demos sequentially:

python3 demos/demo_1_local_basic.py
python3 demos/demo_2_policy_hmac.py
python3 demos/demo_3_multi_node.py
python3 demos/demo_4_observability.py
python3 demos/demo_5_ci_cd_pipeline.py
python3 demos/demo_6_fail_and_recover.py

---

🧩 Architecture Overview

paxect-link-plugin/
├── paxect_link_plugin.py       # Main inbox/outbox bridge (policy, HMAC, logging, resilience)
├── paxect_core.py              # PAXECT Core (deterministic container engine)
└── demos/                      # Enterprise demos 1–6
    ├── demo_1_local_basic.py
    ├── demo_2_policy_hmac.py
    ├── demo_3_multi_node.py
    ├── demo_4_observability.py
    ├── demo_5_ci_cd_pipeline.py
    └── demo_6_fail_and_recover.py

---

⚙️ Installation

Requirements: Python ≥ 3.8 (Core additionally needs zstandard, psutil)

# Virtual environment (recommended)
python3 -m venv .venv
source .venv/bin/activate

# Dependencies for PAXECT Core
python -m pip install --upgrade pip
pip install zstandard psutil

---

✅ Verification

Health check

python3 paxect_link_plugin.py

Expected: startup banner, path summary, and “Watching…” line (Ctrl + C to stop).

Deterministic relay check

export PAXECT_CORE="python $(pwd)/paxect_core.py"
export PAXECT_LINK_INBOX=/tmp/pax_in
export PAXECT_LINK_OUTBOX=/tmp/pax_out
export PAXECT_LINK_POLICY=/tmp/pax_policy.json
mkdir -p "$PAXECT_LINK_INBOX" "$PAXECT_LINK_OUTBOX"

python3 - <<'PY'
import json, os, socket
p=os.environ["PAXECT_LINK_POLICY"]
d={"version":"1.2.0","trusted_nodes":[socket.gethostname(),"localhost"],
   "allowed_suffixes":[".bin",".txt",".json",".csv",".aead",".freq"],
   "max_file_mb":256,"require_sig":False,"auto_delete":True,"log_level":"info"}
open(p,"w").write(json.dumps(d,indent=2))
PY

python3 paxect_link_plugin.py   # terminal A, keep running
# terminal B:
echo "hello" > /tmp/pax_in/hello.txt
# Expect: hello.freq (+ .sha256) appears; 'hello' appears in outbox

✅ This manual relay verification remains valid for all demos 1–6.

---

🧪 Testing & Coverage

The demos double as smoke tests for continuous integration.

Demo	Purpose	CI Integration
05	Deterministic encode/decode + JUnit XML	GitHub Actions, Jenkins, GitLab
06	Fault-injection + automatic self-recovery	Stability regression / resilience tests

Example run:

python3 demos/demo_5_ci_cd_pipeline.py
python3 demos/demo_6_fail_and_recover.py

---

📦 Integration in CI/CD (GitHub Actions Example)

name: PAXECT Link — CI/CD Smoke & Resilience Suite

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  paxect-link-suite:
    runs-on: ubuntu-latest
    timeout-minutes: 15

    steps:
      - name: Checkout repo
        uses: actions/checkout@v4

      - name: Setup Python 3.12
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'

      - name: Create venv + install dependencies
        run: |
          python -m venv .venv
          source .venv/bin/activate
          python -m pip install --upgrade pip
          pip install zstandard psutil

      - name: Run Demo 5 (CI/CD Smoke)
        run: |
          source .venv/bin/activate
          python demos/demo_5_ci_cd_pipeline.py

      - name: Upload JUnit results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: paxect-junit
          path: /tmp/paxect_demo5/junit_smoke.xml

      - name: Run Demo 6 (Fail & Self-Recover)
        run: |
          source .venv/bin/activate
          python demos/demo_6_fail_and_recover.py

Explanation

Step	Purpose
Demo 5	Deterministic CI/CD smoke test — verifies Core + Link and emits JUnit XML.
Upload	Publishes junit_smoke.xml as CI artifact.
Demo 6	Fault-injection + auto-recovery check; ensures resilience under failure.

✅ Both steps exit 0 when healthy, allowing green CI pipelines.

---

🧭 Bridge Diagram

Producer(s)            PAXECT Link                 Consumer(s)
  write → INBOX   ──>  encode (.freq)  ──>  decode  ──> OUTBOX → read
                     (CRC32 + SHA-256)     (verify)

---

📈 Verification Summary

Environment	Result
Ubuntu 24.04 (x86_64)	✅ All six demos completed deterministically
macOS 14 Sonoma	✅ Identical hashes across runs
Windows 11	✅ Inbox/outbox relay + recovery verified

---

🧩 Environment Variables (Link)

Variable	Purpose	Example
PAXECT_LINK_INBOX	Directory to watch for inputs	/tmp/paxect_demo*/inbox
PAXECT_LINK_OUTBOX	Directory to write decoded outputs	/tmp/paxect_demo*/outbox
PAXECT_LINK_POLICY	JSON policy file	/tmp/paxect_demo*/policy.json
PAXECT_LINK_LOG	JSONL log file	/tmp/paxect_demo*/log.jsonl
PAXECT_LINK_MANIFEST	Self manifest path	/tmp/.../link_manifest.json
PAXECT_LINK_HMAC_KEY	HMAC key for signed manifests	supersecret-demo-hmac-key
PAXECT_LINK_LOCK	Lock file path (per node)	/tmp/.../.paxect_link.lock
PAXECT_CORE	How to invoke Core	python paxect_core.py
PAXECT_LINK_POLL_SEC	Polling interval	2.0
PAXECT_LINK_BACKOFF_SEC	Backoff after failure	2.0

---

🔐 Policy Tips

• Add your hostname (e.g., PAXECT-Interface) to trusted_nodes.
• Include .freq in allowed_suffixes.
• Set require_sig: true to enforce HMAC verification.
• Unsigned or invalid peer manifests will be rejected automatically.

---

⚠️ Troubleshooting

• Policy blocks (untrusted_node) → add your hostname to trusted_nodes.
• Two Link instances, one exits → use unique lock files per node.
• PEP 668 errors on Ubuntu → use a virtual environment.
• No output in outbox → check JSONL log for policy_block, encode_error, decode_error.
• Corrupted input (Demo 6) → see checksum_mismatch → then decode in log for recovery proof.

---

🪪 License

All demo scripts and plugins are licensed under Apache-2.0 (see file headers).

---

✅ PAXECT Link Plugin Demo Suite Complete — Enterprise-Ready (1 – 6)

Plugin	Scope	Highlights	Repo
Core	Deterministic container	.freq v42 · multi-channel · CRC32+SHA-256 · cross-OS · offline · no-AI	https://github.com/PAXECT-Interface/paxect-core-plugin.git
AEAD Hybrid	Confidentiality & integrity	Hybrid AES-GCM/ChaCha20-Poly1305 — fast, zero-dep, cross-OS	https://github.com/PAXECT-Interface/paxect-aead-hybrid-plugin
Polyglot	Language bindings	Python · Node.js · Go — identical deterministic pipeline	https://github.com/PAXECT-Interface/paxect-polyglot-plugin
SelfTune 5-in-1	Runtime control & observability	No-AI guardrails, overhead caps, backpressure, jitter smoothing, lightweight metrics	https://github.com/PAXECT-Interface/paxect-selftune-plugin
Link (Inbox/Outbox Bridge)	Cross-OS file exchange	Shared-folder relay: auto-encode non-.freq → .freq, auto-decode .freq → files	https://github.com/PAXECT-Interface/paxect-link-plugin

---

Path to Paid

PAXECT is built to stay free and open-source at its core.

Principles

• Core stays free forever — no lock-in, no hidden fees.
• Volunteers and researchers — full access to source, builds, and discussions.
• Transparency — clear dates, no surprises.
• Fairness — individuals stay free; organizations relying on enterprise features contribute.

Timeline

• Launch phase: from the official PAXECT product release date, all modules — including enterprise — are free for 6 months (global).
• 30 days before renewal: decision to extend the free enterprise phase by another 6 months.
• Core/baseline model: always free with updates (definition in progress).

Why This Matters

• Motivation: volunteers know their work has real impact.
• Stability: enterprises get predictable guarantees and funded maintenance.
• Sustainability: continuous evolution without compromising openness.

---

🤝 Community & Support

Bug or feature request? Open an Issue ›

General questions or collaboration ideas? Join the Discussions ›

If PAXECT Link helped your research, deployment, or enterprise project, please consider giving the repository a ⭐ — it helps others discover the project and supports maintenance.

---

🔄 Updates & Maintenance

PAXECT link Plugin follows an open contribution model.

• Updates, bugfixes, and improvements depend on community and maintainer availability.
• There is no fixed release schedule — stability and determinism are prioritized over speed.
• Enterprises and contributors are encouraged to submit issues or pull requests for any enhancements.
• The project owner focuses on innovation and architectural guidance rather than continuous support.

In short: updates arrive when they are ready — verified, deterministic, and tested across platforms.

💼 Sponsorships & Enterprise Support

PAXECT Link is maintained as a verified enterprise plugin. Sponsorship enables deterministic QA across operating systems.

Enterprise partnership options:

• Deterministic data reproducibility compliance
• CI/CD hardening and interoperability certification
• Air-gapped deployment guidance

How to get involved

• Become a GitHub Sponsor

---

Governance & Ownership

• Ownership: All PAXECT products and trademarks (PAXECT™ name + logo) remain the property of the Owner.
• License: Source code is Apache-2.0; trademark rights are not granted by the code license.
• Core decisions: Architectural decisions and final merges for Core and brand-sensitive repos require Owner approval.
• Contributions: PRs welcome and reviewed by maintainers; merges follow CODEOWNERS + branch protection.
• Naming/branding: Do not use the PAXECT name/logo for derived projects without written permission; see TRADEMARKS.md.

Contact: 📧 PAXECT-Team@outlook.com

✅ Deterministic · Reproducible · Offline

Copyright© 2025 PAXECT Systems. Deterministic interoperability for the modern enterprise.

---

PAXECT Core Complete

Status: v1.0.0 — Initial Public Release — October 22, 2025

The curated PAXECT bundle: Core + AEAD Hybrid + Polyglot + SelfTune + Link — with 10 integrated demos, observability, and deterministic performance across OSes.

What it is: the official reference implementation of the PAXECT ecosystem — a verified, reproducible, cross-OS runtime that showcases the multi-OS bridge and in-freq multi-channel architecture in real workflows.

• Unified Ecosystem: Core + AEAD + SelfTune + Polyglot + Link in one deterministic bundle
• Reproducibility: bit-identical behavior across Linux, macOS, Windows (best-effort: BSD, mobile shells)
• Offline-first: zero telemetry, no network dependencies
• Enterprise-ready: 10 reproducible demo pipelines, audit trail, and metrics endpoints
• Zero-AI Runtime: SelfTune provides adaptive guardrails without ML or heuristics (no cloud)

Relationship

• PAXECT Core is a stand-alone OS-level deterministic bridge (plugin-capable).
• PAXECT Core Complete is the curated bundle that includes Core plus the official plugins and demo suite.
  Use Core when you want a minimal, plug-and-play bridge.
  Use Core Complete when you want the full experience (plugins + demos) out of the box.

---

Installation

Requirements

• Python 3.9 – 3.12 (recommended 3.11+)
• Works on Linux, macOS, Windows, FreeBSD, OpenBSD, Android (Termux), and iOS (Pyto).
• No external dependencies or internet connection required — fully offline-first runtime.

Optional Utilities

Some demos use these standard tools if available:

• bash (for demo_05_link_smoke.sh)
• dos2unix (for normalizing line endings)
• jq (for formatting JSON output)

Install

git clone https://github.com/PAXECT-Interface/paxect-core-complete.git
cd paxect-core-complete
python3 -m venv venv
source venv/bin/activate      # on Windows: venv\Scripts\activate
pip install -e .

Verify the deterministic core import:

python3 -c "import paxect_core; print('PAXECT Core OK')"

Then run any of the integrated demos from the demos/ folder to validate deterministic reproducibility.

---

📁 Repository Structure

paxect-core-complete/
├── paxect_core.py
├── paxect_aead_hybrid_plugin.py
├── paxect_polyglot_plugin.py
├── paxect_selftune_plugin.py
├── paxect_link_plugin.py
├── demos/
│   ├── demo_01_quick_start.py
│   ├── demo_02_integration_loop.py
│   ├── demo_03_safety_throttle.py
│   ├── demo_04_metrics_health.py
│   ├── demo_05_link_smoke.sh
│   ├── demo_06_polyglot_bridge.py
│   ├── demo_07_selftune_adaptive.py
│   ├── demo_08_secure_multichannel_aead_hybrid.py
│   ├── demo_09_enterprise_all_in_one.py
│   └── demo_10_enterprise_stability_faults.py
├── test_paxect_all_in_one.py
├── ENTERPRISE_PACK_OVERVIEW.md
├── SECURITY.md
├── CONTRIBUTING.md
├── CODE_OF_CONDUCT.md
├── TRADEMARKS.md
├── LICENSE
└── .gitignore

---

Modules

Module	Purpose
paxect_core.py	Deterministic runtime · encode/decode · CRC32 + SHA-256 checksums
paxect_aead_hybrid_plugin.py	Hybrid AES-GCM / ChaCha20-Poly1305 encryption for data integrity
paxect_polyglot_plugin.py	Cross-language bridge · UTF-safe transformation between runtimes
paxect_selftune_plugin.py	Adaptive ε-greedy self-tuning · resource-aware control · no AI
paxect_link_plugin.py	Secure inbox/outbox relay · policy validation · offline file sync

---

Plugins (Official)

Plugin	Scope	Highlights	Repo
Core	Deterministic data container	.freq v42 · multi-channel · CRC32 + SHA-256 · cross-OS · offline-first	paxect-core-plugin
AEAD Hybrid	Encryption & Integrity	Hybrid AES-GCM / ChaCha20-Poly1305 — fast, zero dependencies, cross-platform	paxect-aead-hybrid-plugin
Polyglot	Multi-language bridge	Python · Node.js · Go — deterministic pipeline parity	paxect-polyglot-plugin
SelfTune 5-in-1	Runtime control & observability	Guardrails, backpressure, overhead limits, metrics, and jitter smoothing	paxect-selftune-plugin
Link (Inbox/Outbox Bridge)	Cross-OS file exchange	Shared-folder relay: auto-encode/decode .freq containers deterministically	paxect-link-plugin

Plug-and-play: Core operates standalone, with optional plugins attachable via flags or config. Deterministic behavior remains identical across environments.

---

🧪 Demo Suite (01 – 10)

Run reproducible demos from the repository root:

python3 demos/demo_01_quick_start.py
python3 demos/demo_02_integration_loop.py
python3 demos/demo_03_safety_throttle.py
python3 demos/demo_04_metrics_health.py
bash    demos/demo_05_link_smoke.sh
python3 demos/demo_06_polyglot_bridge.py
python3 demos/demo_07_selftune_adaptive.py
python3 demos/demo_08_secure_multichannel_aead_hybrid.py
python3 demos/demo_09_enterprise_all_in_one.py
python3 demos/demo_10_enterprise_stability_faults.py

All demos generate structured JSON audit logs under /tmp/, verifiable through deterministic SHA-256 outputs.

---

Testing & Verification

Internal pytest suites validate core reproducibility. End-users can rely on the integrated demo suite (01–10) for deterministic verification. Each demo reports performance, checksum validation, and exit status cleanly.

---

🔒 Security & Privacy

• Default mode: offline, zero telemetry.
• Sensitive configuration via environment variables.
• AEAD Hybrid is simulation-grade; for production, integrate with verified crypto or HSM.
• Adheres to Digital Hygiene 2027 and NIS2 security standards.
• Follows responsible disclosure in SECURITY.md.

---

🏢 Enterprise Pack

See ENTERPRISE_PACK_OVERVIEW.md for extended features and enterprise integration roadmap.

Includes:

• HSM / KMS / Vault integration
• Extended policy and audit engine
• Prometheus, Grafana, Splunk, and Kafka observability connectors
• Deployment assets (systemd, Helm, Docker)
• Compliance documentation (ISO · IEC · NIST · NIS2)

---

🤝 Community & Governance

• License: Apache-2.0
• Ownership: All PAXECT trademarks and brand assets remain property of the Owner.
• Contributions: PRs welcome; feature branches must pass deterministic CI pipelines.
• Core merges: Require owner approval for brand or architecture-sensitive changes.
• Community Conduct: See CODE_OF_CONDUCT.md

Join as a maintainer or contributor — see CONTRIBUTING.md for details.

---

🔄 Updates & Maintenance

PAXECT Core Complete follows an open contribution and verification-first model:

• No fixed release schedule — determinism prioritized over speed.
• Verified updates only, across OSes and environments.
• Maintainers focus on innovation, reproducibility, and architecture quality.

---

💠 Sponsorships & Enterprise Support

PAXECT Core Complete is a verified, plug-and-play runtime ecosystem unifying all PAXECT modules. Sponsorships fund ongoing cross-platform validation, reproducibility testing, and audit compliance for deterministic and secure data pipelines across Linux, Windows, and macOS.

Enterprise Sponsorship Options

• Infrastructure validation and multi-OS QA
• Deterministic CI/CD performance testing
• OEM and observability integration partnerships
• Extended reproducibility assurance for regulated industries

Get Involved

• 💠 Become a GitHub Sponsor
• 📧 Enterprise or OEM inquiries: enterprise@PAXECT-Team@outlook.com

Sponsorships help sustain open, verifiable, and enterprise-ready innovation.

---

Governance & Ownership

• Ownership: All PAXECT products and trademarks (PAXECT™ name + logo) remain the property of the Owner.
• License: Source code under Apache-2.0; trademark rights are not granted by the license.
• Core decisions: Architectural merges for Core and brand repos require Owner approval.
• Contributions: PRs reviewed under CODEOWNERS and branch protection.
• Brand Use: Do not use PAXECT branding for derivatives without written permission. See TRADEMARKS.md.

---

Path to Paid — Sustainable Open Source

PAXECT Core Complete is free and open-source at its foundation. Sustainable sponsorship ensures long-term maintenance, reproducibility, and enterprise adoption.

Principles

• Core remains free forever — no vendor lock-in.
• Full transparency, open changelogs, and audit-ready releases.
• Global 6-month free enterprise window after public release.
• Community-driven decision-making on renewals and roadmap.

Why This Matters

• Motivates contributors with lasting value.
• Ensures reproducible stability for enterprises.
• Balances open innovation with sustainable funding.

---

Contact

📧 PAXECT-Team@outlook.com 💬 Issues 💭 Discussions

For security disclosures, please follow responsible reporting procedures.

Copyright © 2025 PAXECT Systems — All rights reserved.