worldfoundry 0.2.0__py3-none-any.whl

worldfoundry/models.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class ActionSpec:
+    name: str
+    description: str
+    parameters: dict[str, dict[str, Any]]
+    required: tuple[str, ...] = ()
+
+    def to_dict(self) -> dict[str, Any]:
+        data = asdict(self)
+        data["required"] = list(self.required)
+        return data
+
+
+@dataclass(frozen=True)
+class ValidationCheck:
+    name: str
+    passed: bool
+    message: str
+
+
+@dataclass(frozen=True)
+class ValidationResult:
+    passed: bool
+    score: float
+    checks: tuple[ValidationCheck, ...]
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "passed": self.passed,
+            "score": self.score,
+            "checks": [asdict(check) for check in self.checks],
+        }
+
+
+@dataclass
+class Episode:
+    id: str
+    environment: str
+    task: str
+    instruction: str
+    seed: int
+    status: str
+    state: dict[str, Any]
+    trace: list[dict[str, Any]] = field(default_factory=list)
+    created_at: str = ""
+    updated_at: str = ""
+    validation: ValidationResult | None = None
+
+    def to_dict(self, *, include_state: bool = True, include_trace: bool = False) -> dict[str, Any]:
+        data: dict[str, Any] = {
+            "id": self.id,
+            "environment": self.environment,
+            "task": self.task,
+            "instruction": self.instruction,
+            "seed": self.seed,
+            "status": self.status,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "validation": self.validation.to_dict() if self.validation else None,
+        }
+        if include_state:
+            data["state"] = self.state
+        if include_trace:
+            data["trace"] = self.trace
+        return data
+
+
+@dataclass(frozen=True)
+class StepResult:
+    episode_id: str
+    action: str
+    observation: dict[str, Any]
+    status: str
+    step: int
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+

worldfoundry/platform.py

@@ -0,0 +1,185 @@
+"""Local agent execution and resource managers for the public SDK."""
+from __future__ import annotations
+
+import json
+import uuid
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from .engine import EpisodeEngine
+from .environments import get_environment
+
+
+class WorldFoundryError(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class Resource:
+    id: str
+    name: str
+    kind: str
+    config: dict[str, Any]
+
+
+class Registry:
+    def __init__(self, root: Path):
+        self.root = root / "resources"
+
+    def put(self, resource: Resource) -> Resource:
+        folder = self.root / resource.kind
+        folder.mkdir(parents=True, exist_ok=True)
+        target = folder / f"{resource.id}.json"
+        temporary = target.with_suffix(".tmp")
+        temporary.write_text(json.dumps(resource.__dict__, indent=2) + "\n", encoding="utf-8")
+        temporary.replace(target)
+        return resource
+
+    def get(self, kind: str, resource_id: str) -> Resource:
+        if not resource_id.startswith(f"{kind}_") or "/" in resource_id:
+            raise WorldFoundryError(f"Invalid {kind} ID")
+        target = self.root / kind / f"{resource_id}.json"
+        if not target.exists():
+            raise WorldFoundryError(f"Unknown {kind}: {resource_id}")
+        return Resource(**json.loads(target.read_text(encoding="utf-8")))
+
+    def list(self, kind: str) -> list[Resource]:
+        folder = self.root / kind
+        if not folder.exists():
+            return []
+        return [self.get(kind, path.stem) for path in sorted(folder.glob("*.json"))]
+
+
+class ResourceManager:
+    def __init__(self, registry: Registry, kind: str):
+        self.registry = registry
+        self.kind = kind
+
+    def create(self, name: str | None = None, **config: Any) -> Resource:
+        name = name or config.get("template") or self.kind
+        resource = Resource(f"{self.kind}_{uuid.uuid4().hex[:12]}", name, self.kind, config)
+        return self.registry.put(resource)
+
+    def get(self, resource_id: str) -> Resource:
+        return self.registry.get(self.kind, resource_id)
+
+    def list(self) -> list[Resource]:
+        return self.registry.list(self.kind)
+
+
+class EnvironmentManager(ResourceManager):
+    def create(self, *, template: str, difficulty: str = "beginner", name: str | None = None,
+               config: dict[str, Any] | None = None) -> Resource:
+        aliases = {"customer_support": "support-desk", "support-desk": "support-desk"}
+        if template not in aliases:
+            raise WorldFoundryError(f"Unknown environment template: {template}")
+        if difficulty != "beginner":
+            raise WorldFoundryError("Only beginner difficulty is implemented in the support desk template")
+        return super().create(name=name or template, template=aliases[template],
+                              difficulty=difficulty, settings=config or {})
+
+
+class AgentTools:
+    def __init__(self, engine: EpisodeEngine, episode_id: str, max_steps: int):
+        self.engine = engine
+        self.episode_id = episode_id
+        self.submitted = False
+        self.max_steps = max_steps
+        self.steps = 0
+
+    def act(self, action: str, **parameters: Any) -> dict[str, Any]:
+        if self.submitted:
+            raise WorldFoundryError("Agent already submitted this episode")
+        if self.steps >= self.max_steps:
+            raise WorldFoundryError("Episode action budget exceeded")
+        self.steps += 1
+        return self.engine.act(self.episode_id, action, **parameters).observation
+
+    def submit(self) -> None:
+        self.submitted = True
+
+    def __getattr__(self, action: str) -> Callable[..., dict[str, Any]]:
+        names = {item.name for item in get_environment("support-desk").actions()}
+        if action not in names:
+            raise AttributeError(action)
+        return lambda **parameters: self.act(action, **parameters)
+
+
+class AgentManager(ResourceManager):
+    def __init__(self, registry: Registry):
+        super().__init__(registry, "agent")
+        self.handlers: dict[str, Callable[..., Any]] = {}
+
+    def register(self, *, name: str, handler: Callable[..., Any] | None = None,
+                 framework: str = "python", endpoint: str | None = None) -> Resource:
+        if (handler is None) == (endpoint is None):
+            raise WorldFoundryError("Provide exactly one handler or endpoint")
+        if endpoint:
+            raise WorldFoundryError("Remote agent endpoints are not executable in this local release")
+        if framework != "python":
+            raise WorldFoundryError("Use framework='python' for local callables; ADK runner is pending")
+        resource = self.create(name=name, framework=framework, invocation="python_callable")
+        self.handlers[resource.id] = handler  # live Python objects intentionally stay in process
+        return resource
+
+
+@dataclass
+class TrainingRun:
+    id: str
+    status: str
+    episode_ids: list[str]
+    scores: list[float]
+    report_path: Path
+    report_url: str | None = None
+
+    @property
+    def success_rate(self) -> float:
+        return sum(score == 1.0 for score in self.scores) / len(self.scores) if self.scores else 0.0
+
+    @property
+    def summary(self) -> dict[str, Any]:
+        return {"id": self.id, "status": self.status, "episodes": len(self.episode_ids),
+                "success_rate": self.success_rate, "mean_score": sum(self.scores) / len(self.scores)}
+
+    def wait(self) -> TrainingRun:
+        return self  # local execution currently completes before returning
+
+
+class TrainingManager:
+    def __init__(self, engine: EpisodeEngine, agents: AgentManager, registry: Registry):
+        self.engine, self.agents, self.registry = engine, agents, registry
+
+    def create(self, *, agent: Resource, environment: Resource, episodes: int = 1,
+               concurrency: int = 1, max_steps: int = 30, seed: int = 0) -> TrainingRun:
+        if not 1 <= episodes <= 10000 or concurrency != 1 or not 1 <= max_steps <= 1000:
+            raise WorldFoundryError("episodes, concurrency, and max_steps must be within supported limits")
+        if agent.id not in self.agents.handlers:
+            raise WorldFoundryError("Local callable is not registered in this process")
+        environment = self.registry.get("environment", environment.id)
+        template = environment.config["template"]
+        handler = self.agents.handlers[agent.id]
+        run_id = f"run_{uuid.uuid4().hex[:12]}"
+        ids: list[str] = []
+        scores: list[float] = []
+        failures: list[str | None] = []
+        for index in range(episodes):
+            episode = self.engine.start(template, seed=seed + index)
+            ids.append(episode.id)
+            tools = AgentTools(self.engine, episode.id, max_steps)
+            error = None
+            try:
+                handler(episode.instruction, tools)
+            except Exception as exc:  # noqa: BLE001 - user supplied agent must not abort the batch
+                error = f"{type(exc).__name__}: {exc}"
+            result = self.engine.submit(episode.id)
+            scores.append(result.score)
+            failures.append(error)
+        run = TrainingRun(run_id, "completed", ids, scores,
+                          self.registry.root.parent / "runs" / run_id / "report.json")
+        run.report_path.parent.mkdir(parents=True, exist_ok=True)
+        run.report_path.write_text(json.dumps({**run.summary, "episode_ids": ids,
+                                               "scores": scores, "agent_errors": failures}, indent=2) + "\n")
+        return run
+

worldfoundry/server.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import json
+import re
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Any
+from urllib.parse import urlparse
+
+from .client import WorldFoundry
+from .environments import EnvironmentError
+from .store import EpisodeNotFound
+
+
+def _json_bytes(data: Any) -> bytes:
+    return (json.dumps(data, indent=2) + "\n").encode()
+
+
+class APIHandler(BaseHTTPRequestHandler):
+    server_version = "WorldFoundry/0.1"
+    client: WorldFoundry
+
+    def log_message(self, format: str, *args: Any) -> None:
+        print(f"{self.address_string()} - {format % args}")
+
+    def _send(self, status: int, data: Any, content_type: str = "application/json") -> None:
+        body = _json_bytes(data) if content_type == "application/json" else data.encode()
+        self.send_response(status)
+        self.send_header("Content-Type", f"{content_type}; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _body(self) -> dict[str, Any]:
+        length = int(self.headers.get("Content-Length", "0"))
+        if length == 0:
+            return {}
+        data = json.loads(self.rfile.read(length))
+        if not isinstance(data, dict):
+            raise TypeError("JSON body must be an object")
+        return data
+
+    def do_GET(self) -> None:
+        path = urlparse(self.path).path
+        try:
+            if path == "/health":
+                self._send(200, {"status": "ok"})
+                return
+            if path == "/v1/environments":
+                self._send(200, {"data": self.client.environment_catalog()})
+                return
+            if path == "/v1/episodes":
+                data = [ep.to_dict(include_state=False) for ep in self.client.list_episodes()]
+                self._send(200, {"data": data})
+                return
+            match = re.fullmatch(r"/v1/episodes/([^/]+)", path)
+            if match:
+                self._send(200, self.client.get(match.group(1)).to_dict())
+                return
+            match = re.fullmatch(r"/v1/episodes/([^/]+)/trace", path)
+            if match:
+                episode = self.client.get(match.group(1))
+                text = "\n".join(json.dumps(event, sort_keys=True) for event in episode.trace) + "\n"
+                self._send(200, text, "application/x-ndjson")
+                return
+            self._send(404, {"error": "not_found", "message": f"No route for GET {path}"})
+        except EpisodeNotFound as exc:
+            self._send(404, {"error": "episode_not_found", "message": str(exc.args[0])})
+
+    def do_POST(self) -> None:
+        path = urlparse(self.path).path
+        try:
+            body = self._body()
+            if path == "/v1/episodes":
+                episode = self.client.start(
+                    body.get("environment", "support-desk"),
+                    body.get("task", "incident-triage"),
+                    int(body.get("seed", 0)),
+                )
+                self._send(201, episode.to_dict())
+                return
+            match = re.fullmatch(r"/v1/episodes/([^/]+)/actions", path)
+            if match:
+                action = body.pop("action", None)
+                if not action:
+                    raise ValueError("Body requires an 'action' field")
+                params = body.pop("parameters", body)
+                self._send(200, self.client.act(match.group(1), action, **params).to_dict())
+                return
+            match = re.fullmatch(r"/v1/episodes/([^/]+)/submit", path)
+            if match:
+                self._send(200, self.client.submit(match.group(1)).to_dict())
+                return
+            self._send(404, {"error": "not_found", "message": f"No route for POST {path}"})
+        except json.JSONDecodeError:
+            self._send(400, {"error": "invalid_json", "message": "Request body is not valid JSON"})
+        except (TypeError, ValueError, EnvironmentError) as exc:
+            self._send(400, {"error": "invalid_request", "message": str(exc)})
+        except EpisodeNotFound as exc:
+            self._send(404, {"error": "episode_not_found", "message": str(exc.args[0])})
+
+
+def serve(host: str = "127.0.0.1", port: int = 8787, home: str | None = None) -> None:
+    handler = type("BoundAPIHandler", (APIHandler,), {"client": WorldFoundry(home)})
+    httpd = ThreadingHTTPServer((host, port), handler)
+    print(f"WorldFoundry API listening on http://{host}:{port}")
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        httpd.server_close()
+

worldfoundry/store.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+from .models import Episode, ValidationCheck, ValidationResult
+
+
+class EpisodeNotFound(KeyError):
+    pass
+
+
+class LocalStore:
+    def __init__(self, root: str | Path | None = None):
+        configured = root or os.environ.get("WORLDFOUNDRY_HOME")
+        self.root = Path(configured).expanduser() if configured else Path.home() / ".worldfoundry"
+        self.episodes_dir = self.root / "episodes"
+
+    def save(self, episode: Episode) -> None:
+        self.episodes_dir.mkdir(parents=True, exist_ok=True)
+        path = self.episodes_dir / f"{episode.id}.json"
+        temp = path.with_suffix(".tmp")
+        temp.write_text(json.dumps(episode.to_dict(include_trace=True), indent=2) + "\n", encoding="utf-8")
+        temp.replace(path)
+
+    def load(self, episode_id: str) -> Episode:
+        path = self.episodes_dir / f"{episode_id}.json"
+        if not path.exists():
+            raise EpisodeNotFound(episode_id)
+        data = json.loads(path.read_text(encoding="utf-8"))
+        validation = None
+        if data.get("validation"):
+            raw = data["validation"]
+            validation = ValidationResult(
+                raw["passed"],
+                raw["score"],
+                tuple(ValidationCheck(**check) for check in raw["checks"]),
+            )
+        return Episode(
+            id=data["id"],
+            environment=data["environment"],
+            task=data["task"],
+            instruction=data["instruction"],
+            seed=data["seed"],
+            status=data["status"],
+            state=data["state"],
+            trace=data.get("trace", []),
+            created_at=data["created_at"],
+            updated_at=data["updated_at"],
+            validation=validation,
+        )
+
+    def list(self) -> list[Episode]:
+        if not self.episodes_dir.exists():
+            return []
+        return [self.load(path.stem) for path in sorted(self.episodes_dir.glob("*.json"))]
+
+    def export_trace(self, episode_id: str, path: str | Path) -> Path:
+        episode = self.load(episode_id)
+        target = Path(path)
+        target.parent.mkdir(parents=True, exist_ok=True)
+        lines = (json.dumps(event, sort_keys=True) for event in episode.trace)
+        target.write_text("\n".join(lines) + "\n", encoding="utf-8")
+        return target
+

worldfoundry-0.2.0.dist-info/METADATA

@@ -0,0 +1,238 @@
+Metadata-Version: 2.5
+Name: worldfoundry
+Version: 0.2.0
+Summary: Agent development and training-experience SDK
+Author: WorldFoundry
+License: Apache-2.0
+License-File: LICENSE
+Keywords: agents,evaluation,simulation,training-environments
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# WorldFoundry
+
+**Training infrastructure for AI agents.**
+
+WorldFoundry gives developers programmable environments where agents can practice real-world
+tasks, interact with simulated systems, learn from failures, and improve through repeated
+experiences.
+
+Build agents anywhere. Train and test them in WorldFoundry.
+
+> **Current status:** this repository builds the `worldfoundry` distribution locally. Check the
+> [PyPI project page](https://pypi.org/project/worldfoundry/) for a published release before
+> using registry install commands. The Homebrew formula is planned and is not published.
+
+## What works now
+
+- A Python SDK and `worldfoundry` / `wf` command-line interface.
+- Persistent, stateful episodes in a simulated support desk.
+- Declared action schemas and validation before actions mutate state.
+- Deterministic task grading with per-check results and a numeric score.
+- Complete traces for starts, successful actions, failed actions, and submissions.
+- JSONL trace export.
+- A dependency-free REST API usable with `curl`.
+- Framework-neutral callables ready to wrap as Google ADK function tools.
+- Local SDK resource registration and sequential callable-agent batch runs with JSON reports.
+
+This is trajectory and evaluation infrastructure. It does **not** perform reinforcement learning,
+fine-tuning, reward-model training, or model-weight updates.
+
+The expanded SDK contract and its current limits are in [`docs/sdk-contract.md`](docs/sdk-contract.md).
+The Supabase control-plane schema, private trace storage, and authenticated Edge API are deployed;
+managed Python workers and customer billing are not yet deployed.
+
+The cloud usage ledger records client-reported episodes for operational visibility; it is not a
+billing system. Stripe metering, verified managed-compute usage, and payment webhooks are not
+connected to the SDK. Source is published at [AMallur/WorldFoundry](https://github.com/AMallur/WorldFoundry).
+The GitHub release workflow verifies the package before publishing through PyPI Trusted
+Publishing.
+
+## Install — verified local
+
+From this repository:
+
+```bash
+python3.13 -m venv .venv
+source .venv/bin/activate
+python -m pip install -e .
+worldfoundry --version
+```
+
+With `uv`, without keeping a virtual environment:
+
+```bash
+uvx --python 3.13 --from . worldfoundry --version
+```
+
+The explicit Python version makes the verification environment reproducible; any supported
+Python 3.11–3.13 interpreter can be used.
+
+### Registry installation
+
+Use these commands only when a release is visible on the
+[PyPI project page](https://pypi.org/project/worldfoundry/):
+
+```bash
+pip install worldfoundry
+uvx worldfoundry
+```
+
+Homebrew distribution is planned. This command does not work until a formula is published:
+
+```bash
+# FUTURE: no Homebrew formula has been published
+brew install worldfoundry/tap/worldfoundry
+```
+
+## One-minute CLI experience
+
+Keep state in a project-local folder while experimenting:
+
+```bash
+export WORLDFOUNDRY_HOME="$PWD/.wf-data"
+
+worldfoundry environments list
+worldfoundry episodes start support-desk --task incident-triage --seed 7
+```
+
+Copy the returned episode ID, then act inside the same persistent simulation:
+
+```bash
+EPISODE_ID=ep_replace_me
+
+worldfoundry episodes act "$EPISODE_ID" get_ticket \
+  --params '{"ticket_id":"TCK-100"}'
+worldfoundry episodes act "$EPISODE_ID" set_priority \
+  --params '{"ticket_id":"TCK-100","priority":"critical"}'
+worldfoundry episodes act "$EPISODE_ID" assign \
+  --params '{"ticket_id":"TCK-100","assignee":"on-call"}'
+worldfoundry episodes act "$EPISODE_ID" reply \
+  --params '{"ticket_id":"TCK-100","message":"We acknowledge the outage and have opened an incident."}'
+worldfoundry episodes act "$EPISODE_ID" resolve \
+  --params '{"ticket_id":"TCK-100"}'
+worldfoundry episodes submit "$EPISODE_ID"
+worldfoundry traces export "$EPISODE_ID" --output trace.jsonl
+```
+
+Submission is a terminal gate. A submitted episode becomes `passed` or `failed` and rejects later
+actions. Start a fresh episode for another attempt.
+
+## Python SDK
+
+```python
+from worldfoundry import WorldFoundry
+
+wf = WorldFoundry(".wf-data")
+episode = wf.start("support-desk", task="incident-triage", seed=7)
+
+wf.act(episode.id, "set_priority", ticket_id="TCK-100", priority="critical")
+wf.act(episode.id, "assign", ticket_id="TCK-100", assignee="on-call")
+wf.act(
+    episode.id,
+    "reply",
+    ticket_id="TCK-100",
+    message="We acknowledge the outage and have opened an incident.",
+)
+wf.act(episode.id, "resolve", ticket_id="TCK-100")
+
+result = wf.submit(episode.id)
+print(result.passed, result.score)
+wf.export_trace(episode.id, "trace.jsonl")
+```
+
+A complete runnable version is in [`examples/python_episode.py`](examples/python_episode.py).
+
+## REST API and `curl`
+
+Start the local server:
+
+```bash
+WORLDFOUNDRY_HOME="$PWD/.wf-data" worldfoundry serve --port 8787
+```
+
+In another terminal:
+
+```bash
+curl -s http://127.0.0.1:8787/health
+
+curl -s -X POST http://127.0.0.1:8787/v1/episodes \
+  -H 'content-type: application/json' \
+  -d '{"environment":"support-desk","task":"incident-triage","seed":7}'
+
+EPISODE_ID=ep_replace_me
+
+curl -s -X POST "http://127.0.0.1:8787/v1/episodes/$EPISODE_ID/actions" \
+  -H 'content-type: application/json' \
+  -d '{"action":"set_priority","parameters":{"ticket_id":"TCK-100","priority":"critical"}}'
+
+curl -s -X POST "http://127.0.0.1:8787/v1/episodes/$EPISODE_ID/submit"
+curl -s "http://127.0.0.1:8787/v1/episodes/$EPISODE_ID/trace" > trace.jsonl
+```
+
+See [`examples/curl_episode.sh`](examples/curl_episode.sh) for an end-to-end REST run that extracts
+the episode ID without requiring `jq`.
+
+## Environment contract
+
+Each environment supplies:
+
+1. An initial state generated from a seed.
+2. A task instruction.
+3. Named actions with parameter schemas.
+4. Stateful action handlers that return observations.
+5. Deterministic validators that produce individual checks, a score, and pass/fail.
+
+All interfaces use the same engine and local store. State lives in
+`$WORLDFOUNDRY_HOME/episodes` or `~/.worldfoundry/episodes` by default. Set the environment variable
+or pass `WorldFoundry(path)` / `--home PATH` for isolated runs.
+
+## Google ADK integration path
+
+`worldfoundry.integrations.adk.tools(client, episode_id)` returns two documented Python callables:
+one for environment actions and one for submission. Google ADK can wrap them as function tools
+without making ADK a hard dependency of the core package. See [`docs/adk.md`](docs/adk.md).
+
+## Path to hosted SaaS
+
+The local contract deliberately maps to a hosted service:
+
+| Local MVP | Hosted evolution |
+|---|---|
+| File-backed episode store | Transactional database plus object storage |
+| In-process environment | Isolated worker or sandbox per episode |
+| Local identity | API keys, workspaces, roles, and scoped tokens |
+| Synchronous action | Idempotent action endpoint with call IDs |
+| JSONL file | Queryable traces plus immutable export |
+| One built-in environment | Versioned environment registry and private environments |
+| Deterministic validator | Versioned eval suites, cohorts, and regression dashboards |
+
+Before a public service, add idempotency keys, optimistic concurrency, tenant isolation, quotas,
+signed artifacts, structured logs, worker timeouts, and compatibility tests for environment
+versions. See [`docs/roadmap.md`](docs/roadmap.md) for release gates.
+
+## Develop and test
+
+```bash
+python3.13 -m venv .venv
+source .venv/bin/activate
+python -m pip install -e '.[dev]'
+python -m pytest
+python -m compileall -q src tests examples
+```
+
+The test suite covers a passing SDK episode, failed-action trace recording, CLI persistence and
+export, REST behavior, invalid parameters, and terminal submission semantics.
+
+## License
+
+Apache-2.0. See [`LICENSE`](LICENSE).
+