witbitz-code 1.2.0__py3-none-any.whl

witbitz_code/__init__.py

@@ -0,0 +1,7 @@
+"""witbitz-code: reach OpenCode on this computer from the Spaces Code section, end-to-end encrypted.
+
+The Python implementation of tools/witbitz-code.mjs (docs/opencode-relay.md phase 5b), held to the JS one by shared test
+vectors and cross-implementation tests.
+"""
+
+__version__ = "1.2.0"

witbitz_code/__main__.py

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

witbitz_code/_js.py

@@ -0,0 +1,312 @@
+"""JavaScript semantics this port has to reproduce, in one place.
+
+The JS tools are the reference implementation and the page runs them, so wherever the wire or a shared file depends on
+a JS rule, Python follows the rule rather than its own idiom:
+
+- JSON.stringify: compact, integral floats print as integers (1000, not 1000.0), lone UTF-16 surrogates are escaped,
+  integer-like object keys come first. Byte-identical output keeps the pairings file and the gzip-size threshold equal.
+- String lengths and slices count UTF-16 code units (chunking at 192 KiB, `name.slice(0, 80)`, `id.slice(0, 64)`). A
+  slice may split a surrogate pair exactly as JS does; joining the halves back recombines it.
+- Truthiness, unary `+`, `String(x)`, `Number.isInteger`: the registry and payload readers lean on all of them.
+- atob's "forgiving base64": what the page accepts, Python accepts, and nothing more.
+"""
+
+from __future__ import annotations
+
+import base64
+import decimal
+import json
+import math
+import re
+from typing import Any
+
+MAX_SAFE_INTEGER = 2**53 - 1
+
+
+class _Undefined:
+    """A property that is absent (JS `undefined`), as opposed to JSON null (None)."""
+
+    _inst = None
+
+    def __new__(cls):
+        if cls._inst is None:
+            cls._inst = super().__new__(cls)
+        return cls._inst
+
+    def __bool__(self) -> bool:
+        return False
+
+    def __repr__(self) -> str:
+        return "undefined"
+
+
+UNDEFINED = _Undefined()
+
+# ECMAScript WhiteSpace + LineTerminator — what `\s` and String.prototype.trim() mean in JS (Python's differ: no U+FEFF).
+WS = "\t\n\x0b\x0c\r \xa0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff"
+# JS `.` stops at these; Python's `.` stops only at \n.
+NOT_LT = "[^\n\r\u2028\u2029]"
+_TRIM = re.compile(f"\\A[{WS}]+|[{WS}]+\\Z")
+
+
+def is_num(v: Any) -> bool:
+    return isinstance(v, (int, float)) and not isinstance(v, bool)
+
+
+def truthy(v: Any) -> bool:
+    if v is None or v is False or v is UNDEFINED:
+        return False
+    if is_num(v):
+        return v == v and v != 0
+    if isinstance(v, str):
+        return v != ""
+    return True  # objects and arrays, even empty ones
+
+
+def is_integer(v: Any) -> bool:
+    """Number.isInteger — 42.0 from JSON counts, exactly as JSON.parse("42.0") === 42 in JS."""
+    if not is_num(v):
+        return False
+    return isinstance(v, int) or (math.isfinite(v) and float(v).is_integer())
+
+
+def is_safe_integer(v: Any) -> bool:
+    return is_integer(v) and abs(v) <= MAX_SAFE_INTEGER
+
+
+def strict_eq(a: Any, b: Any) -> bool:
+    """`===` for JSON values: same kind and equal; objects by identity."""
+    if is_num(a) and is_num(b):
+        return a == b
+    if isinstance(a, str) and isinstance(b, str):
+        return a == b
+    if isinstance(a, bool) and isinstance(b, bool):
+        return a == b
+    return a is b
+
+
+def trim(s: str) -> str:
+    return _TRIM.sub("", s)
+
+
+# ── numbers ───────────────────────────────────────────────────────────────────────────────────────────────────────────
+_DEC = re.compile(r"[+-]?(?:Infinity|(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)")
+
+
+def _string_to_number(s: str) -> float:
+    t = trim(s)
+    if t == "":
+        return 0
+    if _DEC.fullmatch(t):
+        return float(t.replace("Infinity", "inf"))
+    for prefix, base, digits in (("0x", 16, "[0-9a-fA-F]"), ("0o", 8, "[0-7]"), ("0b", 2, "[01]")):
+        if re.fullmatch(f"0[{prefix[1]}{prefix[1].upper()}]{digits}+", t):
+            return float(int(t[2:], base))
+    return math.nan
+
+
+def to_number(v: Any) -> float:
+    """Unary `+v`."""
+    if v is UNDEFINED:
+        return math.nan
+    if v is None or v is False:
+        return 0
+    if v is True:
+        return 1
+    if is_num(v):
+        return v
+    if isinstance(v, str):
+        return _string_to_number(v)
+    if isinstance(v, (list, tuple)):
+        return _string_to_number(js_string(v))
+    return math.nan
+
+
+def number_str(x: float) -> str:
+    """Number.prototype.toString() — shortest round-trip digits, JS exponent rules."""
+    if isinstance(x, int) and abs(x) <= MAX_SAFE_INTEGER:
+        return str(x)
+    x = float(x)
+    if x != x:
+        return "NaN"
+    if math.isinf(x):
+        return "Infinity" if x > 0 else "-Infinity"
+    if x == 0:
+        return "0"
+    sign = "-" if x < 0 else ""
+    d = decimal.Decimal(repr(abs(x))).normalize()
+    _, digits, exp = d.as_tuple()
+    s = "".join(map(str, digits))
+    k, n = len(s), len(s) + exp
+    if k <= n <= 21:
+        return sign + s + "0" * (n - k)
+    if 0 < n <= 21:
+        return sign + s[:n] + "." + s[n:]
+    if -6 < n <= 0:
+        return sign + "0." + "0" * (-n) + s
+    e = n - 1
+    mant = s if k == 1 else s[0] + "." + s[1:]
+    return f"{sign}{mant}e{'+' if e >= 0 else '-'}{abs(e)}"
+
+
+def js_string(v: Any) -> str:
+    """String(v)."""
+    if v is UNDEFINED:
+        return "undefined"
+    if v is None:
+        return "null"
+    if v is True:
+        return "true"
+    if v is False:
+        return "false"
+    if is_num(v):
+        return number_str(v)
+    if isinstance(v, str):
+        return v
+    if isinstance(v, (list, tuple)):
+        return ",".join("" if e is None or e is UNDEFINED else js_string(e) for e in v)
+    return "[object Object]"
+
+
+def clean_number(v: float) -> float:
+    """A computed number as JS would hold it for JSON: integral floats become ints (so they print as 5, not 5.0)."""
+    if isinstance(v, float) and math.isfinite(v) and v.is_integer() and abs(v) <= MAX_SAFE_INTEGER:
+        return int(v)
+    return v
+
+
+# ── UTF-16 ────────────────────────────────────────────────────────────────────────────────────────────────────────────
+def utf16_len(s: str) -> int:
+    return len(s.encode("utf-16-le", "surrogatepass")) // 2
+
+
+def utf16_slice(s: str, start: int, end: int | None = None) -> str:
+    b = s.encode("utf-16-le", "surrogatepass")
+    return b[2 * start : None if end is None else 2 * end].decode("utf-16-le", "surrogatepass")
+
+
+def utf16_join(parts) -> str:
+    """''.join, then fuse surrogate halves that a UTF-16 slice split — JS strings do this implicitly."""
+    s = "".join(parts)
+    if not _SURROGATE.search(s):
+        return s
+    return s.encode("utf-16-le", "surrogatepass").decode("utf-16-le", "surrogatepass")
+
+
+_SURROGATE = re.compile("[\ud800-\udfff]")
+
+
+def utf8(s: str) -> bytes:
+    """A JS string as UTF-8 the way fetch/TextEncoder send it: pairs fused, a lone surrogate becomes U+FFFD."""
+    return _SURROGATE.sub("\ufffd", utf16_join([s])).encode("utf-8")
+
+# ── JSON ──────────────────────────────────────────────────────────────────────────────────────────────────────────────
+_ESCAPES = {'"': '\\"', "\\": "\\\\", "\b": "\\b", "\f": "\\f", "\n": "\\n", "\r": "\\r", "\t": "\\t"}
+_NEEDS_ESCAPE = re.compile('["\\\\\x00-\x1f\ud800-\udfff]')
+_INDEX_KEY = re.compile(r"0|[1-9]\d*")
+
+
+def _quote(s: str) -> str:
+    if _SURROGATE.search(s):
+        s = utf16_join([s])  # a pair held as two code points is one character to JS
+    return '"' + _NEEDS_ESCAPE.sub(lambda m: _ESCAPES.get(m.group(0)) or "\\u%04x" % ord(m.group(0)), s) + '"'
+
+
+def _ordered_keys(d: dict) -> list:
+    keys = [k if isinstance(k, str) else js_string(k) for k in d]
+    idx = sorted((k for k in keys if _INDEX_KEY.fullmatch(k) and int(k) < 2**32 - 1), key=int)
+    idx_set = set(idx)
+    return idx + [k for k in keys if k not in idx_set]
+
+
+def stringify(v: Any, indent: int | None = None) -> str:
+    """JSON.stringify(v, null, indent) for JSON-shaped values."""
+    gap = " " * indent if indent else ""
+
+    def ser(x: Any, cur: str) -> str | None:
+        if x is None:
+            return "null"
+        if x is True:
+            return "true"
+        if x is False:
+            return "false"
+        if x is UNDEFINED:
+            return None
+        if is_num(x):
+            return number_str(x) if math.isfinite(x) else "null"
+        if isinstance(x, str):
+            return _quote(x)
+        inner = cur + gap
+        if isinstance(x, (list, tuple)):
+            items = [ser(e, inner) or "null" for e in x]
+            if not items:
+                return "[]"
+            if not gap:
+                return "[" + ",".join(items) + "]"
+            return "[\n" + inner + (",\n" + inner).join(items) + "\n" + cur + "]"
+        if isinstance(x, dict):
+            src = {(k if isinstance(k, str) else js_string(k)): val for k, val in x.items()}
+            members = []
+            for k in _ordered_keys(src):
+                sv = ser(src[k], inner)
+                if sv is not None:
+                    members.append(_quote(k) + (": " if gap else ":") + sv)
+            if not members:
+                return "{}"
+            if not gap:
+                return "{" + ",".join(members) + "}"
+            return "{\n" + inner + (",\n" + inner).join(members) + "\n" + cur + "}"
+        raise TypeError(f"not JSON-serializable: {type(x).__name__}")
+
+    out = ser(v, "")
+    if out is None:
+        raise TypeError("undefined is not JSON")
+    return out
+
+
+def _no_constants(name: str):
+    raise ValueError(f"{name} is not JSON")
+
+
+def parse(text: str) -> Any:
+    """JSON.parse — refuses NaN/Infinity, which Python's json would otherwise accept."""
+    return json.loads(text, parse_constant=_no_constants)
+
+
+def json_bytes(v: Any) -> float:
+    """UTF-8 size of JSON.stringify(v ?? null) — Infinity when it cannot be serialized (compress.js _jsonBytes)."""
+    try:
+        return len(stringify(None if v is UNDEFINED else v).encode("utf-8"))
+    except (TypeError, ValueError, RecursionError):
+        return math.inf
+
+
+# ── base64 ────────────────────────────────────────────────────────────────────────────────────────────────────────────
+_B64_BAD = re.compile(r"[^A-Za-z0-9+/]")
+
+
+def atob(s: str) -> bytes:
+    """WHATWG forgiving-base64 decode (what `atob` accepts). Raises ValueError where atob throws."""
+    t = re.sub(r"[\t\n\x0c\r ]", "", s)
+    if len(t) % 4 == 0:
+        if t.endswith("=="):
+            t = t[:-2]
+        elif t.endswith("="):
+            t = t[:-1]
+    if len(t) % 4 == 1 or _B64_BAD.search(t):
+        raise ValueError("invalid base64")
+    return base64.b64decode(t + "=" * (-len(t) % 4))
+
+
+def btoa(b: bytes) -> str:
+    return base64.b64encode(b).decode("ascii")
+
+
+def b64u(b: bytes) -> str:
+    """base64url, unpadded (every B64/b64u/b64url helper on the JS side)."""
+    return base64.urlsafe_b64encode(b).rstrip(b"=").decode("ascii")
+
+
+def unb64u_loose(s: Any) -> bytes:
+    """deviceLink UNB64 / recovery fromB64url: url alphabet mapped back, then atob (no padding added)."""
+    return atob(js_string(s).replace("-", "+").replace("_", "/"))

witbitz_code/account.py

@@ -0,0 +1,127 @@
+"""Writes to the account: the `computers` registry and the legacy direct-server settings — tools/opencode-pair.mjs.
+
+⚠ The registry and index2 are LIVE ACCOUNT DATA. op:'state' REPLACES a doc, so every write here READS first, refuses
+  unless that read was a definitive 200, merges, writes the whole doc back, and verifies by reading it again.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from . import _js, compress
+from ._js import truthy
+from .computers import (
+    COMPUTERS_DOC,
+    live_computers,
+    norm_registry,
+    with_computer,
+    without_computer,
+)
+from .net import ApiCall
+
+# Account docs above ~24 KB are gzip-wrapped as { z } (roomSync.js pushIndexDoc) — the same rule as the app.
+GZIP_OVER = 24000
+
+
+def _now_ms() -> int:
+    return int(time.time() * 1000)
+
+
+def unwrap_index_state(state: Any) -> Any:
+    return compress.gunzip_b64(state["z"]) if isinstance(state, dict) and isinstance(state.get("z"), str) else state
+
+
+def wrap_index_state(state: Any) -> Any:
+    return {"z": compress.gzip_b64(state)} if compress.HAS_GZIP and compress.json_bytes(state) > GZIP_OVER else state
+
+
+async def read_doc(call: ApiCall, idx: dict, name: str) -> dict:
+    rd = await call({"op": "state", "room": idx["room"], "mk": idx["mk"], "name": name})
+    j = rd.j
+    err = j.get("error") if isinstance(j, dict) else None
+    if rd.status != 200 or not truthy(j) or truthy(err):
+        detail = f": {_js.js_string(err)}" if truthy(err) else ""
+        return {"ok": False, "why": f"{name} read refused ({rd.status}{detail}) — NOT writing"}
+    try:
+        state = j.get("state") if isinstance(j, dict) else None
+        return {"ok": True, "state": unwrap_index_state(state if truthy(state) else None)}
+    except Exception as e:  # a gzip wrap that does not open
+        return {"ok": False, "why": f"{name} unreadable ({e}) — NOT writing"}
+
+
+def _write_body(idx: dict, name: str, patch: Any, summary: str) -> dict:
+    return {"op": "state", "room": idx["room"], "mk": idx["mk"], "name": name, "patch": patch, "summary": summary, "by": "node"}
+
+
+async def publish_computer(*, call: ApiCall, idx: dict, computer_id: str, name: str, relay: str, secret: str,
+                           now: float | None = None) -> dict:
+    """Put (or refresh) this computer in the account's registry."""
+    now = _now_ms() if now is None else now
+    rd = await read_doc(call, idx, COMPUTERS_DOC)
+    if not rd["ok"]:
+        return rd
+    nxt = with_computer(rd["state"], computer_id, {"name": name, "relay": relay, "secret": secret}, now)
+    wr = await call(_write_body(idx, COMPUTERS_DOC, wrap_index_state({**nxt, "at": now}), "computer paired"))
+    if wr.status != 200:
+        return {"ok": False, "why": f"computers write refused ({wr.status})"}
+    back = await read_doc(call, idx, COMPUTERS_DOC)
+    got = norm_registry(back["state"])["computers"].get(computer_id) if back["ok"] else None
+    if not got or got.get("removed") or got.get("secret") != secret:
+        return {"ok": False, "why": "wrote the registry but the read-back does not match — check the account before relying on it"}
+    return {"ok": True, "computers": live_computers(back["state"])}
+
+
+async def unpublish_computer(*, call: ApiCall, idx: dict, computer_id: str, now: float | None = None) -> dict:
+    """Tombstone this computer in the account's registry (its secret leaves the account). Nothing there → nothing written."""
+    now = _now_ms() if now is None else now
+    rd = await read_doc(call, idx, COMPUTERS_DOC)
+    if not rd["ok"]:
+        return rd
+    cur = norm_registry(rd["state"])["computers"].get(computer_id)
+    if not cur or cur.get("removed"):
+        return {"ok": True, "noop": True}
+    nxt = without_computer(rd["state"], computer_id, now)
+    wr = await call(_write_body(idx, COMPUTERS_DOC, wrap_index_state({**nxt, "at": now}), "computer unpaired"))
+    if wr.status != 200:
+        return {"ok": False, "why": f"computers write refused ({wr.status})"}
+    back = await read_doc(call, idx, COMPUTERS_DOC)
+    e = norm_registry(back["state"])["computers"].get(computer_id) if back["ok"] else None
+    if not e or not e.get("removed"):
+        return {"ok": False, "why": "wrote the tombstone but the read-back does not show it"}
+    return {"ok": True}
+
+
+async def clear_legacy_direct(*, call: ApiCall, idx: dict, now: float | None = None) -> dict:
+    """The OLD direct path (pre-relay): empty index2.code.base/pass so no device keeps dialling a server address. Keeps
+    contacts, calendar and the chosen model/agent; nothing set → nothing written."""
+    now = _now_ms() if now is None else now
+    rd = await read_doc(call, idx, "index2")
+    if not rd["ok"]:
+        return rd
+    s = rd["state"] if isinstance(rd["state"], dict) else {}
+    prev = s.get("code") if isinstance(s.get("code"), dict) else None
+    if not prev or (not truthy(prev.get("base")) and not truthy(prev.get("pass"))):
+        return {"ok": True, "noop": True}
+    prev_mod = _js.to_number(prev.get("mod", _js.UNDEFINED))
+    prev_mod = prev_mod if prev_mod == prev_mod and prev_mod != 0 else 0  # Number(prev.mod) || 0
+    code = {
+        "base": "",
+        "pass": "",
+        "model": prev["model"] if isinstance(prev.get("model"), str) else "",
+        "agent": prev["agent"] if isinstance(prev.get("agent"), str) else "",
+        "mod": _js.clean_number(max(now, prev_mod + 1)),
+    }
+    nxt = dict(s)
+    nxt["v"] = s["v"] if truthy(s.get("v")) else 2
+    nxt["code"] = code
+    nxt["at"] = now
+    wr = await call(_write_body(idx, "index2", wrap_index_state(nxt), "code direct server cleared"))
+    if wr.status != 200:
+        return {"ok": False, "why": f"index2 write refused ({wr.status})"}
+    back = await read_doc(call, idx, "index2")
+    bs = back.get("state") if back["ok"] else None
+    bc = bs.get("code") if isinstance(bs, dict) else None
+    if not back["ok"] or not truthy(bs) or not truthy(bc) or not isinstance(bc, dict) or bc.get("base") != "" or bc.get("pass") != "":
+        return {"ok": False, "why": "cleared index2 but the read-back does not match"}
+    return {"ok": True}

witbitz_code/asks.py

@@ -0,0 +1,119 @@
+"""What is waiting on this computer, kept from OpenCode's event stream — tools/code-asks.mjs, in Python.
+
+GET /permission is how Auto mode (auto_runner.py) and the page's card recovery learn what is waiting. Two OpenCode
+behaviours make it unreliable on its own (measured, OpenCode 1.18.30, 2026-09-15):
+
+- ONE ask with an `undefined` in its metadata breaks the list for the WHOLE folder (`400 Expected JSON value, got undefined
+  at [0].metadata.timeout` — webfetch without a timeout). Nothing could see that ask: no card, no Auto; the agent waited.
+- A STOPPED turn leaves its asks in the list — after abort, even after the session is deleted — until each is replied to
+  or OpenCode restarts.
+
+The event stream carries the same asks intact. The book follows /global/event: it adds `permission.asked`, removes
+`permission.replied` (whose id is `requestID`), and when a session goes idle it hands back the asks still recorded for it —
+dead, for the connector to reply to so OpenCode's list heals. Held to the JS answers by tools/code-asks.vectors.json.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from typing import Any
+
+# Frames worth parsing — the stream also carries every token of every session.
+ASK_FRAME = re.compile(r'"(?:permission\.(?:asked|replied)|session\.(?:idle|status|deleted)|server\.instance\.disposed|global\.disposed)"')
+
+MAX_PER_DIR = 200
+MAX_GONE = 1000
+
+
+def _str(x: Any) -> str:
+    return x if isinstance(x, str) and x else ""
+
+
+def _is_ask(a: Any) -> bool:
+    return isinstance(a, dict) and bool(_str(a.get("id"))) and bool(_str(a.get("sessionID")))
+
+
+class AskBook:
+    def __init__(self) -> None:
+        self._by_dir: dict[str, dict[str, dict]] = {}  # directory → {ask id → ask}, in the order asked
+        self._gone: dict[str, bool] = {}  # replied or dead — a list fetched a moment earlier must not bring it back
+
+    def _forget(self, ask_id: str) -> None:
+        self._gone[ask_id] = True
+        if len(self._gone) > MAX_GONE:
+            del self._gone[next(iter(self._gone))]
+
+    def _add(self, directory: str, ask: Any) -> None:
+        if not directory or not _is_ask(ask) or ask["id"] in self._gone:
+            return
+        asks = self._by_dir.setdefault(directory, {})
+        if ask["id"] in asks:
+            return
+        asks[ask["id"]] = ask
+        if len(asks) > MAX_PER_DIR:
+            del asks[next(iter(asks))]
+
+    def _remove(self, ask_id: str) -> None:
+        for directory, asks in list(self._by_dir.items()):
+            if asks.pop(ask_id, None) is not None and not asks:
+                del self._by_dir[directory]
+        self._forget(ask_id)
+
+    def _take_dead(self, directory: str, is_dead: Callable[[dict], bool]) -> list[tuple[str, dict]]:
+        asks = self._by_dir.get(directory)
+        if not asks:
+            return []
+        dead = [(directory, ask) for ask in asks.values() if is_dead(ask)]
+        for _, ask in dead:
+            self._remove(ask["id"])
+        return dead
+
+    def apply(self, frame: Any) -> list[tuple[str, dict]]:
+        """One /global/event frame ({directory, payload: {type, properties}}). Returns the asks it showed to be dead."""
+        frame = frame if isinstance(frame, dict) else {}
+        directory = _str(frame.get("directory"))
+        payload = frame.get("payload") if isinstance(frame.get("payload"), dict) else {}
+        kind = _str(payload.get("type"))
+        p = payload.get("properties") if isinstance(payload.get("properties"), dict) else {}
+        if kind == "global.disposed":
+            self._by_dir.clear()
+            return []
+        if kind == "server.instance.disposed":
+            self._by_dir.pop(_str(p.get("directory")) or directory, None)  # its asks went with it
+            return []
+        if not directory:
+            return []
+        if kind == "permission.asked":
+            self._add(directory, p)
+            return []
+        if kind == "permission.replied":
+            ask_id = _str(p.get("requestID")) or _str(p.get("id"))
+            if ask_id:
+                self._remove(ask_id)
+            return []
+        info = p.get("info") if isinstance(p.get("info"), dict) else {}
+        sid = _str(p.get("sessionID")) or _str(info.get("id"))
+        if not sid:
+            return []
+        status = p.get("status") if isinstance(p.get("status"), dict) else {}
+        idle = kind in ("session.idle", "session.deleted") or (kind == "session.status" and status.get("type") == "idle")
+        return self._take_dead(directory, lambda ask: ask["sessionID"] == sid) if idle else []
+
+    def merge(self, directory: str, lst: Any) -> None:
+        """Asks OpenCode's own list returned (when it works): added, never removed — it may predate an event already seen."""
+        for ask in lst if isinstance(lst, list) else []:
+            self._add(directory, ask)
+
+    def settle_idle(self, directory: str, busy: Any, known: Any) -> list[tuple[str, dict]]:
+        """From GET /session/status (it lists a subagent's session too): every ask whose session is not running is dead.
+        `known`: the ask ids recorded BEFORE the status was read — one that arrived meanwhile is never taken."""
+        running = set(x for x in busy if isinstance(x, str)) if isinstance(busy, list) else set()
+        before = set(x for x in known if isinstance(x, str)) if isinstance(known, list) else set()
+        return self._take_dead(directory, lambda ask: ask["id"] in before and ask["sessionID"] not in running)
+
+    def list(self, directory: str) -> list[dict]:
+        return list(self._by_dir.get(directory, {}).values())
+
+    def directories(self) -> list[str]:
+        return list(self._by_dir)