pgc-runtime 2.0.0__tar.gz

pgc_runtime-2.0.0/LICENSE

@@ -0,0 +1,67 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+Copyright 2026 Bhash Ganti aka Bachi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+
+------------------------
+FULL LICENSE TEXT BELOW
+------------------------
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+   "Licensor" shall mean the copyright owner.
+   "Legal Entity" shall mean the union of the acting entity and all other
+   entities that control, are controlled by, or are under common control.
+   "You" shall mean an individual or Legal Entity exercising permissions.
+   "Source" form shall mean the preferred form for making modifications.
+   "Object" form shall mean any form resulting from mechanical transformation.
+   "Work" shall mean the work of authorship.
+   "Derivative Works" shall mean any work based on the Work.
+   "Contribution" shall mean any work intentionally submitted.
+   "Contributor" shall mean Licensor and any individual submitting Contributions.
+
+2. Grant of Copyright License.
+   Each Contributor grants You a perpetual, worldwide, non-exclusive,
+   no-charge, royalty-free copyright license.
+
+3. Grant of Patent License.
+   Each Contributor grants a patent license to make, use, sell, etc.
+
+4. Redistribution.
+   You may reproduce and distribute copies provided that:
+   - You include a copy of this License
+   - You retain notices
+   - You state modifications
+   - You include NOTICE file if present
+
+5. Submission of Contributions.
+   Contributions are under this License unless stated otherwise.
+
+6. Trademarks.
+   This License does not grant trademark rights.
+
+7. Disclaimer of Warranty.
+   Provided "AS IS", without warranties.
+
+8. Limitation of Liability.
+   No liability for damages.
+
+9. Accepting Warranty or Additional Liability.
+   You may offer support/warranty on your own behalf only.

pgc_runtime-2.0.0/MANIFEST.in

@@ -0,0 +1,8 @@
+exclude *.log
+exclude *.jsonl
+exclude *.sh
+
+prune scripts
+prune testbed
+
+global-exclude __pycache__ *.pyc

pgc_runtime-2.0.0/NOTICE

@@ -0,0 +1,11 @@
+PGS — Protocol-Governed Systems
+Copyright 2026 Bhash Ganti aka Bachi
+
+This project introduces a protocol-first execution model in which:
+
+- Behavior is declared in protocol artifacts
+- Execution is performed by a deterministic runtime
+- Capability implementations are bound at compile time
+- Governance is enforced through invariants and assertions
+
+Extensibility is achieved by declaration, not refactor.

pgc_runtime-2.0.0/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: pgc-runtime
+Version: 2.0.0
+Summary: PGC protocol runtime — executes a sealed snapshot as governed DAG traversal and emits traces (import package: runtime)
+Author-email: Bhash Ganti <bachipeachy@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://omnibachi.org/
+Project-URL: Repository, https://github.com/protocol-governed-computing/protocol_runtime
+Project-URL: Standard, https://doi.org/10.5281/zenodo.22150616
+Keywords: protocol-governed-computing,pgc,protocol,runtime,workflow,execution
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Provides-Extra: reference
+Requires-Dist: pgc-governance>=2.0.0; extra == "reference"
+Dynamic: license-file
+
+# protocol_runtime
+
+**Deterministic execution engine for Protocol-Governed Computing** (import package: `runtime`).
+
+The runtime traverses a precompiled execution graph and produces traceable, governed outcomes. It
+does not discover behavior, interpret intent, or contain business logic. Everything it will do was
+decided at compile time; execution is a traversal of what the snapshot already says.
+
+## Install
+
+```bash
+pip install pgc-runtime
+```
+
+Once installed:
+
+```bash
+protocol_runtime --help
+```
+
+## Where it fits
+
+```
+software_governance    the normative surface every composition rests on
+conformance_workloads  workloads that prove conformance
+business_domains       domains built on the surface
+
+protocol_compiler      source      → compiled projections
+snapshot_assembler     projections → assembled snapshot
+protocol_runtime       snapshot    → execution            (this repo)
+snapshot_inspector     snapshot    → inspection
+```
+
+`protocol_transport` governs the boundary at either end of execution — ingress and egress as
+first-class contracts. The runtime consumes only the **assembled** snapshot, never an individual
+repo's compiled layout.
+
+## What it is, and is not
+
+**It is** a deterministic graph traverser, a trace generator, and a host for the capability
+implementations a snapshot names.
+
+**It is not** a workflow authoring system, a rules engine, a business-logic container, or a
+framework with pluggable behavior. There is no extension point, because an extension point is a
+place where ungoverned behavior could enter.
+
+## Inputs and outputs
+
+```
+snapshot root   the assembled snapshot — the sole source of behavior
+payload         external input (JSON)
+data-root       the state storage boundary; one data root is one instance
+```
+
+A run writes an append-only trace alongside the state its declared side effects produce:
+
+```
+traces/<TRACE_ID>/
+    <TRACE_ID>.jsonl    append-only execution log
+    <TRACE_ID>.md       human-readable summary
+    <TRACE_ID>.png      the execution path, rendered
+
+data/
+    registry/           idempotent state
+    events/             append-only history
+```
+
+## Running
+
+```bash
+./run.sh                                       # warm-boot the sibling assembled snapshot
+./run.sh boot --snapshot /abs/snapshot         # explicit boot
+./run.sh run --wf <domain>::WF_… --data-root /abs/instance
+./run.sh examine /abs/trace.jsonl
+```
+
+`run.sh` wraps the CLI, also installed as the `protocol_runtime` console script, with four
+subcommands:
+
+| command | what it does |
+|---|---|
+| `run` | execute a workflow against a data root |
+| `boot` | warm-boot the assembled snapshot — load and hash-verify every manifest domain |
+| `examine` | analyze a completed trace file |
+| `behavior-logic` | render the execution path from a completed trace as a PNG |
+
+`PGC_SNAPSHOT_ROOT` overrides the snapshot location; `PGC_IMPL_ROOTS` is the colon-separated set of
+roots on `PYTHONPATH` for domain capability implementations.
+
+**Warm reboot is its own proof.** Bringing every manifest domain resident and hash-verified
+establishes that the snapshot is intact and executable before any workflow runs. A surface-only
+snapshot has no workflow to traverse, and warm reboot is exactly what proves it sound anyway.
+
+**A data root is an instance, not an interface.** Two data roots against the same snapshot are two
+independent instances of the same governed behavior.
+
+## How execution works
+
+The runtime loads the compiled graph, admits the request against the intent that declares it, and
+walks the workflow node by node. At each node it executes the capability contract's steps —
+invoking transforms, applying side effects — and routes on the declared outcome. It resolves
+nothing by name at execution time: the compiler assigned integer addresses, and traversal operates
+on those.
+
+Every step emits evidence. The trace is not a log the runtime chose to write; it is the record of
+the path actually taken through a graph that was fixed before the run began, which is what makes a
+run reproducible and reviewable after the fact.
+
+## License
+
+Apache-2.0. See `LICENSE` and `NOTICE`.
+
+---
+
+## The package family
+
+| Package | Repository | Role |
+|---|---|---|
+| `pgc-compiler` | `protocol_compiler` | declarations → compiled projections |
+| `pgc-assembler` | `snapshot_assembler` | projections → sealed snapshot |
+| `pgc-runtime` | `protocol_runtime` | snapshot → governed execution |
+| `pgc-inspector` | `snapshot_inspector` | snapshot → read-only inspection |
+| `pgc-transformation` | `transformation` | change request → protocol artifacts |
+| `pgc-governance` | `software_governance` | the governance surface and its capability implementations |
+| `pgc-workloads` | `conformance_workloads` | the workloads that make conformance observable |
+| `pgc-domains` | `business_domains` | the business domain implementations the composed snapshot binds |
+
+`pip install pgc` brings in the whole family.
+
+**Installing the toolchain is one of two steps.** The compiler resolves the governance surface from
+`PGC_PLATFORM_ROOT` — fail-hard, cwd-independent, zero inference — so the *declarations* come from a
+repository you point at, never from a wheel. A registry inside a package would be a second governance
+surface competing with the repository's, and a build could then be governed by a stale copy.
+
+```bash
+git clone https://github.com/protocol-governed-computing/software_governance
+export PGC_PLATFORM_ROOT=$PWD/software_governance
+pgc            # reports what is installed and whether the anchor resolves
+```
+
+`PGC_BUILD_ROOT` (compiled output, keeping the governance repo read-only) and `PGC_DOMAIN_ROOTS`
+(additional domains contributing their own `registry/structures`) are optional.
+
+**Versioning.** Two schemes, and the published version follows the second.
+
+- **Internal** — each repository's `VERSION` file, a monotonic composition ordinal. PGC versions the
+  composition rather than each repo: they release together and the governance closure forces lockstep,
+  so the ordinal names which composition a repo belongs to. Development happens on `dev/<N>` and each
+  cycle is tagged `release-<N>`. This is not published.
+- **Public** — `PUBLIC_VERSION`, tagged on every component repository. The platform is at **`v2`**.
+
+**The published version is the public one: `v2` is `2.0.0`.** The standard the packages implement is a
+separate artifact on its own track and is not this number.
+
+The standard these packages implement is published separately: https://doi.org/10.5281/zenodo.22150616

pgc_runtime-2.0.0/README.md

@@ -0,0 +1,155 @@
+# protocol_runtime
+
+**Deterministic execution engine for Protocol-Governed Computing** (import package: `runtime`).
+
+The runtime traverses a precompiled execution graph and produces traceable, governed outcomes. It
+does not discover behavior, interpret intent, or contain business logic. Everything it will do was
+decided at compile time; execution is a traversal of what the snapshot already says.
+
+## Install
+
+```bash
+pip install pgc-runtime
+```
+
+Once installed:
+
+```bash
+protocol_runtime --help
+```
+
+## Where it fits
+
+```
+software_governance    the normative surface every composition rests on
+conformance_workloads  workloads that prove conformance
+business_domains       domains built on the surface
+
+protocol_compiler      source      → compiled projections
+snapshot_assembler     projections → assembled snapshot
+protocol_runtime       snapshot    → execution            (this repo)
+snapshot_inspector     snapshot    → inspection
+```
+
+`protocol_transport` governs the boundary at either end of execution — ingress and egress as
+first-class contracts. The runtime consumes only the **assembled** snapshot, never an individual
+repo's compiled layout.
+
+## What it is, and is not
+
+**It is** a deterministic graph traverser, a trace generator, and a host for the capability
+implementations a snapshot names.
+
+**It is not** a workflow authoring system, a rules engine, a business-logic container, or a
+framework with pluggable behavior. There is no extension point, because an extension point is a
+place where ungoverned behavior could enter.
+
+## Inputs and outputs
+
+```
+snapshot root   the assembled snapshot — the sole source of behavior
+payload         external input (JSON)
+data-root       the state storage boundary; one data root is one instance
+```
+
+A run writes an append-only trace alongside the state its declared side effects produce:
+
+```
+traces/<TRACE_ID>/
+    <TRACE_ID>.jsonl    append-only execution log
+    <TRACE_ID>.md       human-readable summary
+    <TRACE_ID>.png      the execution path, rendered
+
+data/
+    registry/           idempotent state
+    events/             append-only history
+```
+
+## Running
+
+```bash
+./run.sh                                       # warm-boot the sibling assembled snapshot
+./run.sh boot --snapshot /abs/snapshot         # explicit boot
+./run.sh run --wf <domain>::WF_… --data-root /abs/instance
+./run.sh examine /abs/trace.jsonl
+```
+
+`run.sh` wraps the CLI, also installed as the `protocol_runtime` console script, with four
+subcommands:
+
+| command | what it does |
+|---|---|
+| `run` | execute a workflow against a data root |
+| `boot` | warm-boot the assembled snapshot — load and hash-verify every manifest domain |
+| `examine` | analyze a completed trace file |
+| `behavior-logic` | render the execution path from a completed trace as a PNG |
+
+`PGC_SNAPSHOT_ROOT` overrides the snapshot location; `PGC_IMPL_ROOTS` is the colon-separated set of
+roots on `PYTHONPATH` for domain capability implementations.
+
+**Warm reboot is its own proof.** Bringing every manifest domain resident and hash-verified
+establishes that the snapshot is intact and executable before any workflow runs. A surface-only
+snapshot has no workflow to traverse, and warm reboot is exactly what proves it sound anyway.
+
+**A data root is an instance, not an interface.** Two data roots against the same snapshot are two
+independent instances of the same governed behavior.
+
+## How execution works
+
+The runtime loads the compiled graph, admits the request against the intent that declares it, and
+walks the workflow node by node. At each node it executes the capability contract's steps —
+invoking transforms, applying side effects — and routes on the declared outcome. It resolves
+nothing by name at execution time: the compiler assigned integer addresses, and traversal operates
+on those.
+
+Every step emits evidence. The trace is not a log the runtime chose to write; it is the record of
+the path actually taken through a graph that was fixed before the run began, which is what makes a
+run reproducible and reviewable after the fact.
+
+## License
+
+Apache-2.0. See `LICENSE` and `NOTICE`.
+
+---
+
+## The package family
+
+| Package | Repository | Role |
+|---|---|---|
+| `pgc-compiler` | `protocol_compiler` | declarations → compiled projections |
+| `pgc-assembler` | `snapshot_assembler` | projections → sealed snapshot |
+| `pgc-runtime` | `protocol_runtime` | snapshot → governed execution |
+| `pgc-inspector` | `snapshot_inspector` | snapshot → read-only inspection |
+| `pgc-transformation` | `transformation` | change request → protocol artifacts |
+| `pgc-governance` | `software_governance` | the governance surface and its capability implementations |
+| `pgc-workloads` | `conformance_workloads` | the workloads that make conformance observable |
+| `pgc-domains` | `business_domains` | the business domain implementations the composed snapshot binds |
+
+`pip install pgc` brings in the whole family.
+
+**Installing the toolchain is one of two steps.** The compiler resolves the governance surface from
+`PGC_PLATFORM_ROOT` — fail-hard, cwd-independent, zero inference — so the *declarations* come from a
+repository you point at, never from a wheel. A registry inside a package would be a second governance
+surface competing with the repository's, and a build could then be governed by a stale copy.
+
+```bash
+git clone https://github.com/protocol-governed-computing/software_governance
+export PGC_PLATFORM_ROOT=$PWD/software_governance
+pgc            # reports what is installed and whether the anchor resolves
+```
+
+`PGC_BUILD_ROOT` (compiled output, keeping the governance repo read-only) and `PGC_DOMAIN_ROOTS`
+(additional domains contributing their own `registry/structures`) are optional.
+
+**Versioning.** Two schemes, and the published version follows the second.
+
+- **Internal** — each repository's `VERSION` file, a monotonic composition ordinal. PGC versions the
+  composition rather than each repo: they release together and the governance closure forces lockstep,
+  so the ordinal names which composition a repo belongs to. Development happens on `dev/<N>` and each
+  cycle is tagged `release-<N>`. This is not published.
+- **Public** — `PUBLIC_VERSION`, tagged on every component repository. The platform is at **`v2`**.
+
+**The published version is the public one: `v2` is `2.0.0`.** The standard the packages implement is a
+separate artifact on its own track and is not this number.
+
+The standard these packages implement is published separately: https://doi.org/10.5281/zenodo.22150616

pgc_runtime-2.0.0/pgc_runtime.egg-info/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: pgc-runtime
+Version: 2.0.0
+Summary: PGC protocol runtime — executes a sealed snapshot as governed DAG traversal and emits traces (import package: runtime)
+Author-email: Bhash Ganti <bachipeachy@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://omnibachi.org/
+Project-URL: Repository, https://github.com/protocol-governed-computing/protocol_runtime
+Project-URL: Standard, https://doi.org/10.5281/zenodo.22150616
+Keywords: protocol-governed-computing,pgc,protocol,runtime,workflow,execution
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Provides-Extra: reference
+Requires-Dist: pgc-governance>=2.0.0; extra == "reference"
+Dynamic: license-file
+
+# protocol_runtime
+
+**Deterministic execution engine for Protocol-Governed Computing** (import package: `runtime`).
+
+The runtime traverses a precompiled execution graph and produces traceable, governed outcomes. It
+does not discover behavior, interpret intent, or contain business logic. Everything it will do was
+decided at compile time; execution is a traversal of what the snapshot already says.
+
+## Install
+
+```bash
+pip install pgc-runtime
+```
+
+Once installed:
+
+```bash
+protocol_runtime --help
+```
+
+## Where it fits
+
+```
+software_governance    the normative surface every composition rests on
+conformance_workloads  workloads that prove conformance
+business_domains       domains built on the surface
+
+protocol_compiler      source      → compiled projections
+snapshot_assembler     projections → assembled snapshot
+protocol_runtime       snapshot    → execution            (this repo)
+snapshot_inspector     snapshot    → inspection
+```
+
+`protocol_transport` governs the boundary at either end of execution — ingress and egress as
+first-class contracts. The runtime consumes only the **assembled** snapshot, never an individual
+repo's compiled layout.
+
+## What it is, and is not
+
+**It is** a deterministic graph traverser, a trace generator, and a host for the capability
+implementations a snapshot names.
+
+**It is not** a workflow authoring system, a rules engine, a business-logic container, or a
+framework with pluggable behavior. There is no extension point, because an extension point is a
+place where ungoverned behavior could enter.
+
+## Inputs and outputs
+
+```
+snapshot root   the assembled snapshot — the sole source of behavior
+payload         external input (JSON)
+data-root       the state storage boundary; one data root is one instance
+```
+
+A run writes an append-only trace alongside the state its declared side effects produce:
+
+```
+traces/<TRACE_ID>/
+    <TRACE_ID>.jsonl    append-only execution log
+    <TRACE_ID>.md       human-readable summary
+    <TRACE_ID>.png      the execution path, rendered
+
+data/
+    registry/           idempotent state
+    events/             append-only history
+```
+
+## Running
+
+```bash
+./run.sh                                       # warm-boot the sibling assembled snapshot
+./run.sh boot --snapshot /abs/snapshot         # explicit boot
+./run.sh run --wf <domain>::WF_… --data-root /abs/instance
+./run.sh examine /abs/trace.jsonl
+```
+
+`run.sh` wraps the CLI, also installed as the `protocol_runtime` console script, with four
+subcommands:
+
+| command | what it does |
+|---|---|
+| `run` | execute a workflow against a data root |
+| `boot` | warm-boot the assembled snapshot — load and hash-verify every manifest domain |
+| `examine` | analyze a completed trace file |
+| `behavior-logic` | render the execution path from a completed trace as a PNG |
+
+`PGC_SNAPSHOT_ROOT` overrides the snapshot location; `PGC_IMPL_ROOTS` is the colon-separated set of
+roots on `PYTHONPATH` for domain capability implementations.
+
+**Warm reboot is its own proof.** Bringing every manifest domain resident and hash-verified
+establishes that the snapshot is intact and executable before any workflow runs. A surface-only
+snapshot has no workflow to traverse, and warm reboot is exactly what proves it sound anyway.
+
+**A data root is an instance, not an interface.** Two data roots against the same snapshot are two
+independent instances of the same governed behavior.
+
+## How execution works
+
+The runtime loads the compiled graph, admits the request against the intent that declares it, and
+walks the workflow node by node. At each node it executes the capability contract's steps —
+invoking transforms, applying side effects — and routes on the declared outcome. It resolves
+nothing by name at execution time: the compiler assigned integer addresses, and traversal operates
+on those.
+
+Every step emits evidence. The trace is not a log the runtime chose to write; it is the record of
+the path actually taken through a graph that was fixed before the run began, which is what makes a
+run reproducible and reviewable after the fact.
+
+## License
+
+Apache-2.0. See `LICENSE` and `NOTICE`.
+
+---
+
+## The package family
+
+| Package | Repository | Role |
+|---|---|---|
+| `pgc-compiler` | `protocol_compiler` | declarations → compiled projections |
+| `pgc-assembler` | `snapshot_assembler` | projections → sealed snapshot |
+| `pgc-runtime` | `protocol_runtime` | snapshot → governed execution |
+| `pgc-inspector` | `snapshot_inspector` | snapshot → read-only inspection |
+| `pgc-transformation` | `transformation` | change request → protocol artifacts |
+| `pgc-governance` | `software_governance` | the governance surface and its capability implementations |
+| `pgc-workloads` | `conformance_workloads` | the workloads that make conformance observable |
+| `pgc-domains` | `business_domains` | the business domain implementations the composed snapshot binds |
+
+`pip install pgc` brings in the whole family.
+
+**Installing the toolchain is one of two steps.** The compiler resolves the governance surface from
+`PGC_PLATFORM_ROOT` — fail-hard, cwd-independent, zero inference — so the *declarations* come from a
+repository you point at, never from a wheel. A registry inside a package would be a second governance
+surface competing with the repository's, and a build could then be governed by a stale copy.
+
+```bash
+git clone https://github.com/protocol-governed-computing/software_governance
+export PGC_PLATFORM_ROOT=$PWD/software_governance
+pgc            # reports what is installed and whether the anchor resolves
+```
+
+`PGC_BUILD_ROOT` (compiled output, keeping the governance repo read-only) and `PGC_DOMAIN_ROOTS`
+(additional domains contributing their own `registry/structures`) are optional.
+
+**Versioning.** Two schemes, and the published version follows the second.
+
+- **Internal** — each repository's `VERSION` file, a monotonic composition ordinal. PGC versions the
+  composition rather than each repo: they release together and the governance closure forces lockstep,
+  so the ordinal names which composition a repo belongs to. Development happens on `dev/<N>` and each
+  cycle is tagged `release-<N>`. This is not published.
+- **Public** — `PUBLIC_VERSION`, tagged on every component repository. The platform is at **`v2`**.
+
+**The published version is the public one: `v2` is `2.0.0`.** The standard the packages implement is a
+separate artifact on its own track and is not this number.
+
+The standard these packages implement is published separately: https://doi.org/10.5281/zenodo.22150616

pgc_runtime-2.0.0/pgc_runtime.egg-info/SOURCES.txt

@@ -0,0 +1,32 @@
+LICENSE
+MANIFEST.in
+NOTICE
+README.md
+pyproject.toml
+pgc_runtime.egg-info/PKG-INFO
+pgc_runtime.egg-info/SOURCES.txt
+pgc_runtime.egg-info/dependency_links.txt
+pgc_runtime.egg-info/entry_points.txt
+pgc_runtime.egg-info/requires.txt
+pgc_runtime.egg-info/top_level.txt
+runtime/__init__.py
+runtime/api.py
+runtime/boot.py
+runtime/cli.py
+runtime/conformance.py
+runtime/ct_errors.py
+runtime/ct_execute.py
+runtime/ct_executor.py
+runtime/dispatcher.py
+runtime/evidence.py
+runtime/loader.py
+runtime/memory.py
+runtime/scheduler.py
+runtime/trace_viz.py
+runtime/examine/__init__.py
+runtime/examine/classifier.py
+runtime/examine/cli.py
+runtime/examine/hint_engine.py
+runtime/examine/locator.py
+runtime/examine/parser.py
+runtime/examine/reporter.py

pgc_runtime-2.0.0/pgc_runtime.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pgc_runtime-2.0.0/pgc_runtime.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+protocol_runtime = runtime.cli:main

pgc_runtime-2.0.0/pgc_runtime.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[reference]
+pgc-governance>=2.0.0

pgc_runtime-2.0.0/pgc_runtime.egg-info/top_level.txt

@@ -0,0 +1 @@
+runtime