authdrift-harness 0.1.0__py3-none-any.whl

authdrift/__init__.py

@@ -0,0 +1,6 @@
+"""Explicit, synchronous revocation experiments."""
+from .core.scenario import Scenario
+from .core.runner import run
+from .hooks.lifecycle import checkpoint
+
+__all__ = ["Scenario", "run", "checkpoint"]

authdrift/__main__.py

@@ -0,0 +1,3 @@
+from .cli.main import main
+
+raise SystemExit(main())

authdrift/cli/main.py

@@ -0,0 +1,32 @@
+import argparse
+import runpy
+import sys
+from pathlib import Path
+
+from authdrift import run
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(prog="authdrift")
+    commands = parser.add_subparsers(dest="command", required=True)
+    command = commands.add_parser("run", help="execute a trusted local scenario file")
+    command.add_argument("scenario", type=Path)
+    command.add_argument("--repeats", type=int, default=1)
+    command.add_argument("--json", type=Path, default=Path("authdrift-results.json"))
+    args = parser.parse_args(argv)
+    try:
+        namespace = runpy.run_path(str(args.scenario.resolve()))
+        source = namespace.get("build_scenario", namespace.get("scenario"))
+        if source is None:
+            raise ValueError("scenario file must export build_scenario() or scenario")
+        report = run(source, repeats=args.repeats, json_path=args.json)
+        print(f"Evidence: {args.json}")
+        return {"CLOSED": 0, "REVOCATION_ESCAPE": 1,
+                "BASELINE_FAILURE": 2, "INVALID_EXPERIMENT": 3}[report["result"]]
+    except Exception as exc:
+        print(f"authdrift: {exc}", file=sys.stderr)
+        return 3
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

authdrift/core/events.py

@@ -0,0 +1,12 @@
+from time import monotonic_ns
+
+
+class Events:
+    def __init__(self):
+        self.start = monotonic_ns()
+        self.items = []
+
+    def add(self, event, **details):
+        self.items.append({"sequence": len(self.items), "event": event,
+                           "t_ms": (monotonic_ns() - self.start) / 1_000_000,
+                           **details})

authdrift/core/injector.py

@@ -0,0 +1,36 @@
+import inspect
+from time import monotonic, sleep
+
+
+class InvalidExperiment(Exception):
+    pass
+
+
+def invoke(callback):
+    value = callback()
+    if inspect.isawaitable(value):
+        if inspect.iscoroutine(value):
+            value.close()
+        raise InvalidExperiment("async callbacks are unsupported; supply a synchronous wrapper")
+    return value
+
+
+def predicate(callback):
+    value = invoke(callback)
+    if type(value) is not bool:
+        raise InvalidExperiment("authoritative predicates must return bool")
+    return value
+
+
+def revoke_and_confirm(scenario, events):
+    events.add("revocation_requested")
+    invoke(scenario.revoke)
+    deadline = monotonic() + scenario.confirmation_timeout
+    while True:
+        confirmed = predicate(scenario.revoked)
+        if monotonic() > deadline:
+            raise InvalidExperiment("revocation confirmation timed out")
+        if confirmed:
+            events.add("revocation_confirmed")
+            return
+        sleep(min(scenario.poll_interval, max(0, deadline - monotonic())))

authdrift/core/result.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class Outcome(str, Enum):
+    CLOSED = "CLOSED"
+    REVOCATION_ESCAPE = "REVOCATION_ESCAPE"
+    BASELINE_FAILURE = "BASELINE_FAILURE"
+    INVALID_EXPERIMENT = "INVALID_EXPERIMENT"

authdrift/core/runner.py

@@ -0,0 +1,125 @@
+import json
+from pathlib import Path
+from uuid import uuid4
+
+from .events import Events
+from .injector import InvalidExperiment, invoke, predicate, revoke_and_confirm
+from .result import Outcome
+from .scenario import Scenario
+from ..hooks.lifecycle import _hook
+
+
+def _experiment(source, mode):
+    events = Events()
+    evidence = {"run_id": str(uuid4()), "experiment": mode, "events": events.items}
+    token = None
+    reached = False
+    injection_error = None
+    try:
+        scenario = source if isinstance(source, Scenario) else invoke(source)
+        if not isinstance(scenario, Scenario):
+            raise InvalidExperiment("factory must return Scenario")
+        evidence["scenario"] = scenario.name
+        if scenario.reset is not None:
+            invoke(scenario.reset)
+        if isinstance(source, Scenario) and scenario.reset is None:
+            raise InvalidExperiment("a Scenario instance requires reset; alternatively pass a fresh factory")
+        if predicate(scenario.committed) or predicate(scenario.revoked):
+            raise InvalidExperiment("experiment must start with valid authority and an empty sink")
+        events.add("experiment_ready")
+
+        def hook(name):
+            nonlocal reached, injection_error
+            events.add("checkpoint", name=name)
+            if name != scenario.trigger or reached:
+                return
+            reached = True
+            if mode != "mid_flight":
+                return
+            try:
+                if predicate(scenario.committed):
+                    raise InvalidExperiment("effect already committed before injection")
+                revoke_and_confirm(scenario, events)
+                # A commit during revocation cannot be ordered after confirmation.
+                if predicate(scenario.committed):
+                    raise InvalidExperiment("effect present at confirmation; commit ordering is ambiguous")
+                events.add("sink_absent_after_confirmation")
+            except Exception as exc:
+                injection_error = exc
+                raise
+
+        if mode == "negative":
+            revoke_and_confirm(scenario, events)
+            if predicate(scenario.committed):
+                raise InvalidExperiment("revocation itself changed the sink")
+        token = _hook.set(hook)
+        invoke(scenario.run)
+        events.add("workflow_completed")
+        if injection_error is not None:
+            raise injection_error
+        if mode == "mid_flight" and not reached:
+            raise InvalidExperiment("trigger checkpoint not reached")
+        if mode != "positive" and not predicate(scenario.revoked):
+            raise InvalidExperiment("authority was restored during the experiment")
+        committed = predicate(scenario.committed)
+        events.add("effect_observed" if committed else "effect_absent")
+        evidence["committed"] = committed
+        if mode == "positive":
+            result = "PASS" if committed else Outcome.INVALID_EXPERIMENT.value
+        elif mode == "negative":
+            result = Outcome.BASELINE_FAILURE.value if committed else "PASS"
+        else:
+            result = (Outcome.REVOCATION_ESCAPE if committed else Outcome.CLOSED).value
+        evidence["result"] = result
+    except Exception as exc:
+        evidence["result"] = Outcome.INVALID_EXPERIMENT.value
+        evidence["reason"] = f"{type(exc).__name__}: {exc}"
+        events.add("experiment_invalid", reason=evidence["reason"])
+    finally:
+        if token is not None:
+            _hook.reset(token)
+    return evidence
+
+
+def run(scenario, *, repeats=1, json_path=None, quiet=False):
+    """Run isolated positive, negative, and mid-flight experiments per repetition.
+
+    Pass a fresh Scenario factory or a Scenario with a reset callback. Callbacks
+    must terminate, and run() must wait for all effects to become observable.
+    """
+    if type(repeats) is not int or repeats < 1:
+        raise ValueError("repeats must be a positive integer")
+    if not isinstance(scenario, Scenario) and not callable(scenario):
+        raise TypeError("expected Scenario or factory")
+    if _hook.get() is not None:
+        raise ValueError("nested experiments are unsupported")
+    trials = []
+    for index in range(repeats):
+        experiments = []
+        for mode in ("positive", "negative", "mid_flight"):
+            result = _experiment(scenario, mode)
+            experiments.append(result)
+            if result["result"] != "PASS":
+                break
+        trials.append({"repetition": index + 1, "result": experiments[-1]["result"],
+                       "experiments": experiments})
+    escapes = sum(t["result"] == Outcome.REVOCATION_ESCAPE for t in trials)
+    valid = sum(t["result"] in (Outcome.CLOSED, Outcome.REVOCATION_ESCAPE) for t in trials)
+    priority = (Outcome.INVALID_EXPERIMENT, Outcome.BASELINE_FAILURE,
+                Outcome.REVOCATION_ESCAPE, Outcome.CLOSED)
+    overall = next(o.value for o in priority if any(t["result"] == o for t in trials))
+    report = {"schema_version": "1.0", "result": overall, "repeats": repeats,
+              "valid_trials": valid, "escapes": escapes,
+              "escape_rate": escapes / valid if valid else None, "trials": trials}
+    if json_path is not None:
+        Path(json_path).write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
+    if not quiet:
+        for trial in trials:
+            print(f"Trial {trial['repetition']}: {trial['result']}")
+            for experiment in trial["experiments"]:
+                print(f"  {experiment['experiment']}: {experiment['result']}")
+                if "reason" in experiment:
+                    print(f"    {experiment['reason']}")
+        rate = f"{report['escape_rate']:.1%}" if valid else "unavailable"
+        print(f"Escapes: {escapes}/{valid} valid trials ({rate}); total trials: {repeats}")
+    return report

authdrift/core/scenario.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from typing import Callable
+import math
+
+
+@dataclass
+class Scenario:
+    name: str
+    run: Callable[[], None]
+    revoke: Callable[[], None]
+    revoked: Callable[[], bool]
+    committed: Callable[[], bool]
+    trigger: str = "authority_observed"
+    reset: Callable[[], None] | None = None
+    confirmation_timeout: float = 1.0
+    poll_interval: float = 0.001
+
+    def __post_init__(self):
+        if not self.name or not self.trigger:
+            raise ValueError("name and trigger must be nonempty")
+        for value in (self.confirmation_timeout, self.poll_interval):
+            if not math.isfinite(value) or value <= 0:
+                raise ValueError("timeouts and polling intervals must be finite and positive")

authdrift/hooks/lifecycle.py

@@ -0,0 +1,14 @@
+from contextvars import ContextVar
+
+_hook = ContextVar("authdrift_checkpoint", default=None)
+
+
+def checkpoint(name: str):
+    """Pause this synchronous workflow for the active experiment's injection.
+
+    Outside an experiment this is a no-op. Thread/process propagation is not
+    automatic; a workflow must join all consequential work before returning.
+    """
+    hook = _hook.get()
+    if hook is not None:
+        hook(name)

authdrift_harness-0.1.0.dist-info/METADATA

@@ -0,0 +1,260 @@
+Metadata-Version: 2.4
+Name: authdrift-harness
+Version: 0.1.0
+Summary: A developer testing harness for confirmed authority changes in agent workflows
+License-Expression: MIT
+Project-URL: Repository, https://github.com/cheerstopriya/authdrift
+Project-URL: Issues, https://github.com/cheerstopriya/authdrift/issues
+Project-URL: Documentation, https://github.com/cheerstopriya/authdrift#readme
+Project-URL: Security, https://github.com/cheerstopriya/authdrift/security/advisories/new
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# AuthDrift
+
+**Can your AI agent still act after you revoke its authority?**
+
+AuthDrift is a developer testing harness for injecting confirmed authority changes
+into running agent trajectories and observing whether consequential effects still
+commit. It reproduces the gap between an earlier approval and a later action.
+It does not enforce policy or protect a running agent.
+
+## A 30-second example
+
+An approval is checked, then withdrawn while the workflow is paused. Does the
+refund still happen?
+
+```python
+# Naive: reuse the earlier decision.
+approved = approval.valid()
+authdrift.checkpoint("authority_observed")
+prepare_refund()
+if approved:
+    issue_refund()
+```
+
+```python
+# Corrected for this synchronous fixture: consult current authority.
+approved = approval.valid()
+authdrift.checkpoint("authority_observed")
+prepare_refund()
+if approval.valid():
+    issue_refund()
+```
+
+These illustrative snippets assume revocation invalidates outstanding effects.
+The runnable fixtures below explicitly define that contract. In concurrent
+systems the final check and mutation must be atomic with respect to revocation;
+a separate recheck alone does not guarantee that.
+
+## Installation
+
+Python **3.10+**, **no runtime dependencies**. From a source checkout:
+
+```sh
+git clone https://github.com/cheerstopriya/authdrift.git
+cd authdrift
+python -m venv .venv
+# Windows PowerShell: .venv\Scripts\Activate.ps1
+# macOS/Linux: source .venv/bin/activate
+python -m pip install -e .
+authdrift --help
+```
+
+Version 0.1.0 is prepared for release. PyPI publication is pending;
+use the source installation above until publication is confirmed.
+The distribution name is `authdrift-harness`; the Python import and CLI remain
+`authdrift`. The existing PyPI package named `authdrift` is a different project.
+Source builds require setuptools >= 77, normally supplied by pip's isolated
+build environment. Examples are included in the repository/source distribution.
+The connected editable-install workflow passed on Windows and Ubuntu with Python
+3.10, 3.12, and 3.13; see [GitHub validation](release/validation.md).
+
+## Quick start
+
+```sh
+authdrift run examples/refund/scenario.py --repeats 20 --json vulnerable.json
+authdrift run examples/refund/safe.py --repeats 20 --json safe.json
+```
+
+The controlled vulnerable fixture reports `REVOCATION_ESCAPE` (exit **1**);
+the corrected fixture reports `CLOSED` (exit **0**).
+
+In AuthDrift's deliberately vulnerable controlled fixtures, all 20/20 runs
+produced `REVOCATION_ESCAPE`; the corresponding corrected fixtures produced
+20/20 `CLOSED`. These counts are fixture runs, not vulnerabilities discovered in
+independent agents. The scenario's declared authority contract gives the security
+classification its meaning; AuthDrift cannot infer that contract.
+
+Measured final summary lines for the refund commands:
+
+```text
+vulnerable: Escapes: 20/20 valid trials (100.0%); total trials: 20
+corrected:  Escapes: 0/20 valid trials (0.0%); total trials: 20
+```
+
+Run all three families and the tests:
+
+```sh
+python benchmarks/run.py
+python -m unittest discover -s tests -v
+```
+
+See [release validation](release/validation.md) for measured results and
+exact commands. The fixtures use in-memory effect records, not real payments,
+LLM calls, or durable external services.
+
+## How AuthDrift works
+
+```text
+Workflow observes authority
+          |
+Checkpoint pauses continuation
+          |
+Request authority change -> independently confirm state
+          |
+Verify effect is still absent
+          |
+Resume the same workflow -> inspect authoritative sink state
+```
+
+Each repetition uses fresh state for positive, pre-revoked negative, and
+mid-flight controls. Failed controls prevent that mid-flight trial from running.
+Confirmation reads the supplied authority predicate, not the revocation callback's
+return value or model narration.
+
+## Outcomes
+
+**Scenario contract required:** confirmed revocation must invalidate outstanding,
+uncommitted effects. A policy/configuration change alone does not establish this.
+The v0.1 API assumes this contract; it cannot discover or verify it automatically.
+Do not use its security classifications for unspecified upstream semantics.
+
+| Outcome | Meaning under the scenario contract | CLI exit |
+| --- | --- | --- |
+| `REVOCATION_ESCAPE` | Effect absent after confirmation, present after continuation | 1 |
+| `CLOSED` | Authority remains revoked; no effect observed after completion, scoped to this trial | 0 |
+| `BASELINE_FAILURE` | Pre-revoked control commits; temporal interpretation stops | 2 |
+| `INVALID_EXPERIMENT` | Failed positive control, bad predicates, missing checkpoint, callback error, or ambiguous ordering | 3 |
+
+JSON schema 1.0 contains controls, per-experiment IDs, ordered monotonic events,
+reasons, counts, and escape rate over valid mid-flight trials only (null if none).
+Mixed reports prioritize invalid experiments, baseline failures, escapes, then
+closed outcomes. CLI errors also exit 3. JSON does not yet separate observation
+from security interpretation; see [methodology](research/methodology.md).
+
+## Included scenarios
+
+| Family | Authority | Controlled effect | Implementations |
+| --- | --- | --- | --- |
+| Refund | Approval | Refund record | [vulnerable](examples/refund/scenario.py), [corrected](examples/refund/safe.py) |
+| Delegation | Worker eligibility | Worker result | [vulnerable](examples/delegation/scenario.py), [corrected](examples/delegation/safe.py) |
+| Session | Session authorization | Protected-action record | [vulnerable](examples/session/scenario.py), [corrected](examples/session/safe.py) |
+
+Each directory documents its authority contract. Delegation is a synchronous
+worker fixture, not a distributed-agent integration.
+
+## Writing your own scenario
+
+```python
+import authdrift
+
+def build_scenario():
+    # Contract: revoked approval invalidates every outstanding refund.
+    state = {"approved": True, "refunds": []}
+
+    def workflow():
+        approved = state["approved"]
+        authdrift.checkpoint("authority_observed")
+        if approved:
+            state["refunds"].append("refund")
+
+    return authdrift.Scenario(
+        name="refund-revocation",
+        run=workflow,
+        revoke=lambda: state.update(approved=False),
+        revoked=lambda: not state["approved"],
+        committed=lambda: bool(state["refunds"]),
+        trigger="authority_observed",
+    )
+
+if __name__ == "__main__":
+    authdrift.run(build_scenario)
+```
+
+CLI files export `build_scenario()` or `scenario`. Prefer a factory creating
+fresh authority and sink state for each experiment. A `Scenario` instance requires
+`reset=` restoring authorization and clearing the sink. Callbacks are synchronous;
+predicates return actual booleans. Optional `confirmation_timeout` and
+`poll_interval` default to 1 second and 0.001 seconds.
+
+## Methodology and validity
+
+Place the checkpoint after authority observation and before any effect. With
+truthful monotonic sink state, no independent writers, and synchronous continuation,
+absence after confirmation followed by presence establishes causal ordering:
+observation < confirmed revocation < commit. Exact commit time is not measured.
+`effect_observed` is an observation timestamp; **Post-Revocation Commit Delay
+(PRCD)** is not calculated from it.
+
+The workflow must join all consequential work before returning. Revocation must
+persist without regrant; effects must not be erased. Predicates independently
+read actual authority and sink state without side effects. Factory isolation is
+a caller obligation, not a sandbox. Read [methodology](research/methodology.md)
+and [threat model](research/threat-model.md) before interpreting results.
+
+## What AuthDrift does not do
+
+No enforcement, automatic interception, framework adapters, universal compatibility,
+async execution, or production validation. Threads/processes do not automatically
+inherit the checkpoint hook. Confirmation polling has a timeout, but the harness
+cannot safely preempt blocked callbacks. Scenario files execute Python: load only
+trusted code. CLOSED is not proof of general revocation closure.
+
+## External validation status
+
+| Specimen | Execution status | Security outcome |
+| --- | --- | --- |
+| LangGraph airline | `BLOCKED_NOT_EXECUTED` | None |
+| Goose | `BLOCKED_NOT_EXECUTED`; `SEMANTICS_UNSPECIFIED` | None |
+
+These are validation-attempt provenance, not successful external validation or
+AuthDrift failures. No LangGraph or Goose vulnerability is claimed. Details and
+the failed Ollama memory preflight: [external validation](research/external-validation.md).
+
+## Related research
+
+The intended contribution is developer-facing testing, injection, and reproduction
+tooling. AuthDrift does not claim to invent stale authority, TOCTOU, commit-time
+authorization, or revocation closure. See [related work](research/related-work.md).
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Independent specimens are welcome with
+honest execution provenance and explicit authority contracts. For suspected
+harness vulnerabilities, see [SECURITY.md](SECURITY.md).
+
+## License
+
+[MIT](LICENSE). Retained upstream specimen material keeps its own license.
+
+## Trusted code and report privacy
+
+AuthDrift executes user-supplied Python scenarios. Running a scenario is
+equivalent to executing trusted Python code. AuthDrift is not a sandbox.
+Only execute scenarios you trust.
+
+Exceptions and error messages may be included in generated result artifacts
+and console output. Users should review and sanitize reports before sharing
+or publishing them. AuthDrift does not automatically redact secrets or personal
+data. Keep raw reports private by default.

authdrift_harness-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+authdrift/__init__.py,sha256=-1hiQXsk0GNTRWTKVlxCy3PMT4tqOMlMVLpqbJQ5iT8,208
+authdrift/__main__.py,sha256=v3re0grUuwzafBOzjQRJBSEvNO6-5A3Q9YULs8vGgF0,56
+authdrift/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+authdrift/cli/main.py,sha256=2_9IRGFqPyQSfaaTa6N_MlluQQrO9-QcLtFNw-xS8dY,1252
+authdrift/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+authdrift/core/events.py,sha256=G9dNZYzS4PC3WvuB2XHsb2cyhulcto2whj9WRvGRh0A,369
+authdrift/core/injector.py,sha256=0nH9hB1xywJNn2KJXx3eMduix5W6-bjXOJVX6_aRd9c,1080
+authdrift/core/result.py,sha256=su5GtX7nv1peAfjj0G_TcUPPx0o1biwytDgFu-7FX_8,212
+authdrift/core/runner.py,sha256=ILCCT63Sa9-TOvhg95nyhM6JnY3aIBlkc0hn_F2mwMA,6000
+authdrift/core/scenario.py,sha256=LqeKqlgYrbMcQT2BE1x7F-qKwzoTlnkkEt00bg7D9Yc,782
+authdrift/hooks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+authdrift/hooks/lifecycle.py,sha256=Lq6qjBAak76HMFPnZ4f_BRpvigetU1lPJXRn2z6RoEI,444
+authdrift_harness-0.1.0.dist-info/licenses/LICENSE,sha256=ulEcXozLIQEujHbn7LsIeIPapYVtuPpFXaACbGdKP3U,1100
+authdrift_harness-0.1.0.dist-info/METADATA,sha256=wCA0aO_t5MGg0blRGrH9-rYPFTwOguewqvOHNqOW0dw,10908
+authdrift_harness-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+authdrift_harness-0.1.0.dist-info/entry_points.txt,sha256=KjBAaKB5kHet1FO5QdHxF7hsqR429C_sr6NRGT4F8mo,54
+authdrift_harness-0.1.0.dist-info/top_level.txt,sha256=UQa1boU2TfoVHpzRj_kwHKsdInJc0WKjie44Jst4CnI,10
+authdrift_harness-0.1.0.dist-info/RECORD,,

authdrift_harness-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

authdrift_harness-0.1.0.dist-info/entry_points.txt

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

authdrift_harness-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AuthDrift contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

authdrift_harness-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+authdrift