flyrail 0.1.0__py3-none-any.whl

flyrail/__init__.py

@@ -0,0 +1,13 @@
+"""flyrail - BYOF server-driven UI core.
+
+Python API is reactpy-style but transport/V DOM agnostic:
+  - you build dict trees with helpers (Stack, Text, Button, ...)
+  - Layout.render(state) replaces callables with {"handlerId": ...} descriptors
+"""
+from .core import component, pure, Slot, Stack, Text, Button, TextField
+from .layout import Layout
+from .driver import Driver
+from .hooks import use_state, use_memo, use_effect
+from .asgi import create_ws_app
+
+__all__ = ["component", "pure", "Slot", "Stack", "Text", "Button", "TextField", "Layout", "Driver", "use_state", "use_memo", "use_effect", "create_ws_app"]

flyrail/asgi.py

@@ -0,0 +1,77 @@
+"""Framework-free ASGI websocket adapter: the async-host recipe.
+
+One state + Driver + Layout per connection; no dependency beyond stdlib.
+FastAPI/Starlette/Django-Channels users mount this where they handle
+websockets (see README Hosting); everyone else copies the 30-line shape.
+"""
+from __future__ import annotations
+import asyncio
+import inspect
+import json
+from typing import Any, Callable
+
+from .driver import Driver
+from .layout import Layout
+
+
+def create_ws_app(
+    render_fn: Callable[[Any], dict],
+    *,
+    state_factory: Callable[[], Any] = dict,
+    version_fn: Callable[[], Any] | None = None,
+    allowed_types: set[str] | None = None,
+    strict: bool = False,
+    on_message: Callable[[dict, Any], Any] | None = None,
+):
+    """Return an ASGI websocket app serving one flyrail session per connection."""
+    _version_of = version_fn or (lambda: None)
+
+    async def app(scope, receive, send):
+        if scope["type"] != "websocket":
+            raise RuntimeError("flyrail ASGI app handles websocket scope only")
+        layout = Layout(render_fn, allowed_types=allowed_types, strict=strict)
+        driver = Driver(layout)
+        state = state_factory()
+
+        async def send_json(env: dict) -> None:
+            await send({"type": "websocket.send", "text": json.dumps(env)})
+
+        await send({"type": "websocket.accept"})
+        snap = layout.snapshot(state, seq=1)
+        driver.seq = 1
+        await send_json(snap)
+
+        run_task = asyncio.create_task(
+            driver.run(lambda: state, send_json, _version_of)
+        )
+        try:
+            while True:
+                msg = await receive()
+                if msg["type"] == "websocket.disconnect":
+                    break
+                if msg["type"] != "websocket.receive":
+                    continue
+                data = json.loads(msg.get("text") or msg.get("bytes") or "{}")
+                if data.get("chan") != "ui":
+                    if on_message is not None:
+                        res = on_message(data, state)
+                        if inspect.isawaitable(res):
+                            await res
+                    continue
+                kind = data.get("type")
+                if kind == "action":
+                    await layout.adispatch(
+                        data["handlerId"], state, data.get("event"))
+                    driver.invalidate()
+                elif kind == "resync-request":
+                    driver.seq += 1
+                    await send_json(layout.snapshot(state, driver.seq))
+                # Unknown ui subtypes ignored (forward-compat, mirrors store).
+        finally:
+            run_task.cancel()
+            try:
+                await run_task
+            except asyncio.CancelledError:
+                pass
+
+    return app

flyrail/core.py

@@ -0,0 +1,107 @@
+"""Declarative element constructors. No VDOM dependency."""
+from __future__ import annotations
+import functools
+from typing import Any, Callable
+
+
+def component(fn=None, *, key_arg: str | None = None):
+    """Declare a component. Calling it returns a lazy node that Layout
+    expands with per-instance hook state (keyed by key=, else position).
+    """
+    def wrap(f):
+        @functools.wraps(f)
+        def invoke(*args, **kwargs):
+            key = kwargs.pop("key", None)
+            return {"type": "__Component__", "fn": f, "key": key,
+                    "args": args, "kwargs": kwargs}
+        invoke._is_flyrail_component = True
+        invoke._key_arg = key_arg
+        invoke._component_fn = f
+        return invoke
+    return wrap(fn) if fn else wrap
+
+
+def pure(fn=None):
+    """Opt-in contract: output is a pure function of (arguments, hook slots).
+
+    Declares, not verifies: Layout may skip re-renders when the host version
+    is unchanged or when a component's arguments are unchanged, and strict mode
+    double-renders to spot-check. Unmarked renders always re-render. If you lie,
+    the stale UI is your bug.
+
+    Marks both sides of @component so either decorator order works: Layout
+    expands the inner function, while a host reading the flag off the name it
+    was given sees the wrapper.
+    """
+    def wrap(f):
+        f._flyrail_pure = True
+        inner = getattr(f, "_component_fn", None)
+        if inner is not None:
+            inner._flyrail_pure = True
+        return f
+    return wrap(fn) if fn else wrap
+
+
+def _opts(event: str, prevent_default: bool, stop_propagation: bool,
+          throttle_ms: int | None) -> dict:
+    """Per-event wire options. throttleMs is omitted when unset (minimal wire)."""
+    opts: dict[str, Any] = {"preventDefault": prevent_default,
+                            "stopPropagation": stop_propagation}
+    if throttle_ms is not None:
+        opts["throttleMs"] = throttle_ms
+    return {event: opts}
+
+
+def _el(type_: str, *children: Any, key: Any = None, on_click: Callable | None = None,
+        event_options: dict | None = None, **props: Any) -> dict:
+    node: dict[str, Any] = {"type": type_, "props": props}
+    if key is not None:
+        node["key"] = key
+    if children:
+        # flatten one level of lists (for [... for ...] splats)
+        flat: list[Any] = []
+        for c in children:
+            if isinstance(c, list):
+                flat.extend(c)
+            else:
+                flat.append(c)
+        node["children"] = flat
+    if on_click is not None:
+        node["on_click"] = on_click
+    if event_options:
+        node["event_options"] = event_options
+    return node
+
+
+def Stack(*children: Any, key: Any = None, **props: Any) -> dict:
+    return _el("Stack", *children, key=key, **props)
+
+
+def Text(value: str, key: Any = None, **props: Any) -> dict:
+    return _el("Text", key=key, value=value, **props)
+
+
+def Button(label: str, on_click: Callable | None = None, key: Any = None, *,
+           prevent_default: bool = True, stop_propagation: bool = False,
+           throttle_ms: int | None = None, **props: Any) -> dict:
+    return _el("Button", key=key, on_click=on_click,
+               event_options=_opts("on_click", prevent_default,
+                                   stop_propagation, throttle_ms) if on_click else None,
+               label=label, **props)
+
+
+def TextField(key: Any = None, on_change: Callable | None = None, *,
+              prevent_default: bool = True, stop_propagation: bool = False,
+              throttle_ms: int | None = None, **props: Any) -> dict:
+    node = _el("TextField", key=key, **props)
+    if on_change is not None:
+        node["on_change"] = on_change
+        node["event_options"] = _opts("on_change", prevent_default,
+                                      stop_propagation, throttle_ms)
+    return node
+
+
+def Slot(name: str, default: Any = None) -> dict:
+    """Hot-path placeholder. Renderer subscribes by name; tick sends slot values
+    directly instead of diffing the whole tree."""
+    return {"type": "__Slot__", "props": {"name": name, "default": default}}

flyrail/driver.py

@@ -0,0 +1,55 @@
+"""Host scheduling seam: one primitive for tick, async, and naive hosts."""
+from __future__ import annotations
+import asyncio
+from typing import Any, Callable
+
+from .layout import Layout
+
+
+class Driver:
+    """Wraps Layout with dirty-flag scheduling and caller-owned seq.
+
+    Tick hosts:   invalidate() per tick (or on sim change); flush(state, version).
+    Async hosts:  invalidate() from event handlers; await run(state_fn, send).
+    Naive hosts:  invalidate() + flush() around every message.
+    Thread-safe invalidate: safe to call from any thread; the run loop
+    (single asyncio loop assumption) wakes via call_soon_threadsafe.
+    """
+
+    def __init__(self, layout: Layout):
+        self.layout = layout
+        self.seq = 0
+        self._event = asyncio.Event()
+
+    def invalidate(self) -> None:
+        self.layout.invalidate()
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+        if loop is None:
+            self._event.set()
+        else:
+            loop.call_soon_threadsafe(self._event.set)
+
+    def flush(self, state: Any, version: Any = None) -> dict | None:
+        """Render+diff if dirty/version-changed; seq-numbered envelope or None."""
+        ops = self.layout.tick(state, version)
+        if not ops:
+            return None
+        self.seq += 1
+        return {"chan": "ui", "type": "patch", "seq": self.seq, "ops": ops}
+
+    async def run(
+        self,
+        state_fn: Callable[[], Any],
+        send: Callable[[dict], Any],
+        version_fn: Callable[[], Any] = lambda: None,
+    ) -> None:
+        """Never returns; cancel to stop. Bursts coalesce into one flush."""
+        while True:
+            await self._event.wait()
+            self._event.clear()
+            env = self.flush(state_fn(), version_fn())
+            if env is not None:
+                await send(env)

flyrail/hooks.py

@@ -0,0 +1,175 @@
+"""Minimal React-style hooks for component-local UI state. Sync only.
+
+Rules (React's, enforced by convention + loud errors):
+- call hooks unconditionally at the top of a @component body, same order
+  every render;
+- never call hooks outside a @component body;
+- give repeated components distinct key= values.
+
+Renders are serial per Layout. Two Layouts on two threads are fine: the frame
+stack is thread-local, so neither can see the other's hook slots.
+"""
+from __future__ import annotations
+import threading
+from typing import Any, Callable
+
+
+class _Stack(threading.local):
+    """Frame stack, innermost last, private to the thread that renders.
+
+    One Layout renders serially, but a host with more than one Layout may well
+    drive them from different threads -- a tick loop per session is an ordinary
+    shape. A module-global stack lets those renders interleave and hands a
+    component another component's slots, which surfaces later as impossible
+    state rather than as an error.
+    """
+
+    def __init__(self):
+        self.frames: list = []
+
+
+_stack = _Stack()
+
+
+class _Frame:
+    __slots__ = ("slots", "index", "schedule")
+
+    def __init__(self, slots: list, schedule: Callable[[], None]):
+        self.slots = slots
+        self.index = 0
+        self.schedule = schedule
+
+
+def enter(slots: list, schedule: Callable[[], None]) -> _Frame:
+    frame = _Frame(slots, schedule)
+    _stack.frames.append(frame)
+    return frame
+
+
+def exit() -> None:
+    if not _stack.frames:
+        raise RuntimeError("hook frames unbalanced (concurrent renders?)")
+    _stack.frames.pop()
+
+
+def _frame() -> _Frame:
+    if not _stack.frames:
+        raise RuntimeError("hooks may only be called inside a @component body")
+    return _stack.frames[-1]
+
+
+def use_state(initial: Any = None):
+    """Component-local state. Returns (value, setter).
+
+    Setter accepts a value or an updater fn. Re-renders are scheduled via
+    Layout.invalidate; identical values skip the schedule. Initializer
+    callables run once (to store a function itself, wrap it in lambda).
+    """
+    frame = _frame()
+    i = frame.index
+    frame.index += 1
+    if i >= len(frame.slots):
+        frame.slots.append(["state", initial() if callable(initial) else initial])
+    cell = frame.slots[i]
+    if cell[0] != "state":
+        raise RuntimeError(
+            "hook order changed between renders: call hooks unconditionally "
+            "in the same order every render")
+    def set_state(new: Any) -> None:
+        old = cell[1]
+        nxt = new(old) if callable(new) else new
+        try:
+            changed = bool(nxt != old)
+        except Exception:
+            changed = True
+        if changed:
+            cell[1] = nxt
+            frame.schedule()
+    return cell[1], set_state
+
+
+def use_memo(fn: Callable[[], Any], deps: list | tuple):
+    """Cached derived value; recomputed only when deps change."""
+    frame = _frame()
+    i = frame.index
+    frame.index += 1
+    if i >= len(frame.slots):
+        value = fn()
+        frame.slots.append(["memo", list(deps), value])
+        return value
+    cell = frame.slots[i]
+    if cell[0] != "memo":
+        raise RuntimeError(
+            "hook order changed between renders: call hooks unconditionally "
+            "in the same order every render")
+    if _deps_changed(cell[1], deps):
+        cell[1] = list(deps)
+        cell[2] = fn()
+    return cell[2]
+
+
+def use_effect(fn: Callable[[], Any], deps: list | tuple) -> None:
+    """Run fn after the render commits; re-run it when deps change.
+
+    fn may return a cleanup, which runs before the next run of that effect and
+    once more when the component leaves the tree -- which is what makes an
+    effect the right place for anything that has to be undone: a highlight, a
+    subscription, a lock.
+
+    Synchronous, like the rest of these hooks. A tick host has nowhere to await
+    and an async effect would need a loop and a task per effect; running on the
+    commit keeps the ordering obvious (cleanup, then run) and keeps flyrail
+    free of asyncio in the render path.
+
+    Fail-loud: a cleanup that raises aborts the render (and the tick driving
+    it) instead of being swallowed. Keep cleanups total.
+    """
+    frame = _frame()
+    i = frame.index
+    frame.index += 1
+    if i >= len(frame.slots):
+        frame.slots.append(["effect", list(deps), None, fn])
+        return
+    cell = frame.slots[i]
+    if cell[0] != "effect":
+        raise RuntimeError(
+            "hook order changed between renders: call hooks unconditionally "
+            "in the same order every render")
+    if _deps_changed(cell[1], deps):
+        cell[1] = list(deps)
+        cell[3] = fn
+
+
+def run_effects(slots: list) -> None:
+    """Run whatever this component's render scheduled, cleaning up first."""
+    for cell in slots:
+        if cell[0] != "effect" or cell[3] is None:
+            continue
+        pending, cell[3] = cell[3], None
+        cleanup, cell[2] = cell[2], None
+        if cleanup is not None:
+            cleanup()
+        cell[2] = pending()
+
+
+def run_cleanups(slots: list) -> None:
+    """Unwind this component's effects, for a component leaving the tree."""
+    for cell in slots:
+        if cell[0] == "effect" and cell[2] is not None:
+            cleanup, cell[2] = cell[2], None
+            cleanup()
+
+
+def _deps_changed(old: list, new: list | tuple) -> bool:
+    new = list(new)
+    if len(old) != len(new):
+        return True
+    for a, b in zip(old, new):
+        if a is b:
+            continue
+        try:
+            if a != b:
+                return True
+        except Exception:
+            return True  # exotic values (ndarray): recompute rather than lie
+    return False

flyrail/layout.py

@@ -0,0 +1,578 @@
+"""Transport-agnostic layout: handler registry, wire serialization, diffing."""
+from __future__ import annotations
+import copy
+import functools
+import inspect
+from typing import Any, Callable
+
+from . import hooks as _hooks
+
+
+def _unchanged(old: Any, new: Any) -> bool:
+    """Whether new says the same as old, erring towards "changed".
+
+    Exotic values (ndarray and friends) return something that is not a bool
+    from ==; those are reported as changed rather than guessed at, the same way
+    _deps_changed treats them.
+    """
+    try:
+        return bool(old == new)
+    except Exception:
+        return False
+
+
+def _is_async(fn: Any) -> bool:
+    """Whether calling fn starts a coroutine, without calling it.
+
+    functools.partial and callable objects wrap the real function, so unwrap
+    before asking; otherwise a partial around an async def reads as sync.
+    """
+    target = fn
+    while isinstance(target, functools.partial):
+        target = target.func
+    if inspect.iscoroutinefunction(target):
+        return True
+    call = getattr(target, "__call__", None)
+    return call is not None and inspect.iscoroutinefunction(call)
+
+
+def _segment(child: Any, index: int) -> Any:
+    """What names a child within its parent: its key, or its position.
+
+    Position alone made a handler id move when its siblings did, so a click on
+    a row that had shifted up reached whatever now sat where it used to. A key
+    is exactly the promise that this element is the same element, so use it.
+
+    Keys must be unique among siblings: duplicates serialize the same id and
+    the registry keeps the last registration. Components reject duplicates;
+    plain nodes do not, so this is a documented must-not rather than a check.
+    """
+    if isinstance(child, dict):
+        key = child.get("key")
+        if key is not None:
+            return key
+    return index
+
+
+def _escape(path: str) -> str:
+    return path.replace("~", "~0").replace("/", "~1")
+
+
+#: Wire defaults for event descriptors. preventDefault is True because a
+#: socket-driven control must never trigger browser navigation (reload =
+#: dead session); opt out explicitly with prevent_default=False. Shape
+#: mirrors reactpy's eventHandlers entries for cross-compat.
+EVENT_DEFAULTS = {"preventDefault": True, "stopPropagation": False}
+
+
+def _keys_of(items: list) -> list | None:
+    """The list's element keys, or None if it is not keyed throughout.
+
+    Reconciling by key needs every element to be a keyed dict with keys unique
+    within the list; anything else and position is all there is to go on.
+    Unhashable keys (a list as a key) cannot be reconciled either -- they
+    fall back to replacing, rather than raising mid-diff.
+    """
+    keys = []
+    for item in items:
+        if not isinstance(item, dict):
+            return None
+        key = item.get("key")
+        if key is None:
+            return None
+        keys.append(key)
+    try:
+        unique = len(set(keys)) == len(keys)
+    except TypeError:
+        return None
+    return keys if unique else None
+
+
+def _diff_keyed_list(old: list, new: list, path: str, keyed_lists: bool) -> list[dict] | None:
+    """Per-element ops for two keyed lists, or None to fall back to a replace.
+
+    Emitted in apply order against a running copy, because RFC6902 array
+    pointers are indices: a remove shifts everything after it, so the ops only
+    mean anything applied in sequence from the same baseline -- which is what
+    the committed tree guarantees.
+    """
+    old_keys, new_keys = _keys_of(old), _keys_of(new)
+    if old_keys is None or new_keys is None:
+        return None
+
+    ops: list[dict] = []
+    working = list(old)
+    keys = list(old_keys)
+
+    wanted = set(new_keys)
+    for index in range(len(working) - 1, -1, -1):
+        if keys[index] not in wanted:
+            ops.append({"op": "remove", "path": f"{path}/{index}"})
+            del working[index]
+            del keys[index]
+
+    present = set(keys)
+    for index, key in enumerate(new_keys):
+        if key not in present:
+            ops.append({"op": "add", "path": f"{path}/{index}", "value": new[index]})
+            working.insert(index, new[index])
+            keys.insert(index, key)
+            present.add(key)
+
+    if keys != new_keys:
+        # Same elements, different order. RFC6902 has `move`, but the ops this
+        # emits are add/replace/remove, so a reorder is not expressible here;
+        # let the caller replace the list outright rather than emit something
+        # a client cannot apply.
+        return None
+
+    for index, (before, after) in enumerate(zip(working, new)):
+        ops.extend(_diff(before, after, f"{path}/{index}", keyed_lists))
+    return ops
+
+
+def _diff(old: Any, new: Any, path: str = "", keyed_lists: bool = True) -> list[dict]:
+    """Minimal RFC6902 diff. Dicts recurse; keyed lists reconcile by key.
+
+    Lists used to replace wholesale, on the reasoning that a client reconciles
+    arrays by `key` anyway. That is true of the DOM and irrelevant to the wire:
+    the whole list has already crossed the socket by the time the client
+    reconciles it, so one changed label re-sent every sibling it had.
+    """
+    ops: list[dict] = []
+    if _unchanged(old, new):
+        return ops
+    if isinstance(old, dict) and isinstance(new, dict):
+        for k in old:
+            if k not in new:
+                ops.append({"op": "remove", "path": f"{path}/{_escape(k)}" or "/"})
+        for k, v in new.items():
+            p = f"{path}/{_escape(k)}"
+            if k not in old:
+                ops.append({"op": "add", "path": p, "value": v})
+            else:
+                ops.extend(_diff(old[k], v, p, keyed_lists))
+        return ops
+    if keyed_lists and isinstance(old, list) and isinstance(new, list):
+        keyed = _diff_keyed_list(old, new, path, keyed_lists)
+        if keyed is not None:
+            return keyed
+    return [{"op": "replace", "path": path or "/", "value": new}]
+
+
+class Layout:
+    """One per session. Bring your own socket/tick.
+
+    ``render(state)`` serializes callables to ``{"handlerId": ...}``;
+    ``diff_and_commit(tree)`` returns RFC6902-ish ops, or ``[]`` when nothing
+    changed so the tick loop sends nothing; ``tick(state)`` does both.
+    ``dispatch(handlerId, state, event)`` routes client actions back to the
+    registered Python callable; ``set_slot(name, value)`` pushes hot per-tick
+    values past the diff entirely.
+    """
+
+    def __init__(self, render_fn: Callable[[Any], dict], allowed_types: set[str] | None = None,
+                 strict: bool = False, keyed_lists: bool = True,
+                 memo: bool = True):
+        #: Reconcile keyed lists element by element instead of replacing them
+        #: whole. The ops stay within add/replace/remove, and the bundled
+        #: client applies array pointers already, so this is on by default.
+        #: Turn it off for a client that only understands object pointers.
+        self.keyed_lists = keyed_lists
+        #: Skip re-running a @pure component whose arguments are unchanged and
+        #: nothing under which went stale. Only @pure components are eligible,
+        #: so an unmarked component still re-renders every time. Off turns the
+        #: whole thing back into an unconditional render, which is what you
+        #: want when a stale panel has you suspecting a lying @pure.
+        self.memo = memo
+        self.render_fn = render_fn
+        self.allowed_types = allowed_types
+        self.strict = strict
+        self.registry: dict[str, Callable] = {}
+        self._last_tree: Any = None
+        #: The committed tree as rendered, not the defensive copy, so an
+        #: unchanged render can be recognised by identity before anything is
+        #: compared element by element.
+        self._last_source: Any = None
+        self._slots: dict[str, Any] = {}
+        self._hooks: dict = {}
+        self._hooks_seen: dict = {}
+        self._hooks_visited: set = set()
+        self._hooks_arity: dict = {}
+        #: Per-slot memo: slot_id -> (args, kwargs, expanded subtree).
+        self._memo: dict = {}
+        #: Slots expanded beneath each slot last render, so a component can ask
+        #: whether anything under it went stale, not just itself.
+        self._subtree: dict = {}
+        #: Per-slot serialized form: slot_id -> (expanded, path, tree, handlers).
+        #: Keyed on the expanded object and the path it was serialized at, both
+        #: of which have to still hold for the cached tree to be the right
+        #: answer -- handler ids are built from the path.
+        self._serial: dict = {}
+        #: id(expanded subtree) -> slot_id, for the slots currently memoised.
+        #: Rebuilt each render; the objects are held alive by _memo, so their
+        #: ids cannot be recycled underneath it.
+        self._memo_root_by_id: dict = {}
+        self._expanding: list = []
+        self._dirty_slots: set = set()
+        #: Slots in the order they finished expanding, which is children before
+        #: parents, so an effect sees its children already committed.
+        self._effect_order: list = []
+        self._version: Any = None
+        self._dirty = True
+
+    def invalidate(self) -> None:
+        """Mark dirty: the next tick() re-renders regardless of version.
+        Scheduling seam for hook dispatch and the Driver.
+
+        Deliberately does not drop memoised subtrees. Driver documents
+        invalidate() per tick for tick hosts, so clearing here would mean the
+        memo never survives a tick and buys nothing for the main use case.
+        Host state reaches a component through its arguments, which the memo
+        compares, so anything the host actually changed re-renders on that
+        basis. A @pure component that reads host state it was not passed is
+        lying, and this is the stale UI the decorator warns about; reach for
+        reset() or memo=False when chasing one.
+        """
+        self._dirty = True
+
+    def reset(self) -> None:
+        """Drop every memoised subtree, forcing the next render to run all of
+        them. For a host that mutates state components read without being
+        handed it, and for bisecting a suspected @pure that is not."""
+        self._memo.clear()
+        self._serial.clear()
+
+    def _invalidate_slot(self, slot_id: Any) -> None:
+        """A hook in this component set new state: only it needs re-running."""
+        self._dirty = True
+        self._dirty_slots.add(slot_id)
+
+    def render(self, state: Any) -> dict:
+        self.registry.clear()
+        tree = self._render_once(state)
+        if self.strict and getattr(self.render_fn, "_flyrail_pure", False):
+            again = self._render_once(state)
+            if again != tree:
+                raise AssertionError(
+                    "render_fn marked @pure produced different trees across "
+                    "two immediate renders; remove @pure or eliminate the "
+                    "nondeterminism (time, random, counters, unversioned reads)")
+        self._run_effects()
+        self._dirty = False
+        return tree
+
+    def _render_once(self, state: Any) -> dict:
+        self._hooks_seen = {}
+        self._hooks_visited = set()
+        self._effect_order = []
+        self._memo_root_by_id = {id(entry[2]): slot_id
+                                 for slot_id, entry in self._memo.items()}
+        expanded = self._expand(self.render_fn(state))
+        for k in list(self._hooks):
+            if k not in self._hooks_visited:
+                # Leaving the tree: unwind its effects before its state goes.
+                _hooks.run_cleanups(self._hooks[k])
+                del self._hooks[k]
+                self._hooks_arity.pop(k, None)
+                # An unmounted component must not leave a memo behind: the same
+                # slot_id can be handed to a later instance, which would then
+                # start from the old instance's subtree.
+                stale = self._memo.pop(k, None)
+                if stale is not None:
+                    # Dropping the last reference to that subtree frees it, and
+                    # a later allocation can be handed the same id. Forget the
+                    # mapping rather than let an unrelated node match it.
+                    self._memo_root_by_id.pop(id(stale[2]), None)
+                self._serial.pop(k, None)
+                self._subtree.pop(k, None)
+                self._dirty_slots.discard(k)
+        collected: dict[str, Callable] = {}
+        tree = self._serialize(expanded, path="0", collected=collected)
+        self.registry.update(collected)
+        if self.allowed_types:
+            self._check_allowlist(tree)
+        return tree
+
+    def _run_effects(self) -> None:
+        """Commit point: effects run once the tree they describe is built.
+
+        A reused subtree scheduled nothing, so nothing of it runs -- which is
+        the behaviour you want and falls out for free.
+        """
+        for slot_id in self._effect_order:
+            slots = self._hooks.get(slot_id)
+            if slots is not None:
+                _hooks.run_effects(slots)
+
+    def _reusable(self, slot_id: Any, fn: Any, node: dict) -> Any:
+        """The cached subtree for this component, if reusing it is safe.
+
+        Safe means: it was marked @pure, its arguments still compare equal, its
+        own hooks have not been written to, and nothing expanded beneath it has
+        either. Strict mode never reuses -- its whole job is to render twice and
+        compare, which a cache would quietly turn into one render.
+        """
+        if not self.memo or self.strict or not getattr(fn, "_flyrail_pure", False):
+            return None
+        remembered = self._memo.get(slot_id)
+        if remembered is None:
+            return None
+        if slot_id in self._dirty_slots:
+            return None
+        if self._dirty_slots & self._subtree.get(slot_id, frozenset()):
+            return None
+        args, kwargs, result = remembered
+        if not _unchanged(args, node.get("args", ())):
+            return None
+        if not _unchanged(kwargs, node.get("kwargs", {})):
+            return None
+        return result
+
+    def _mark_reused(self, slot_id: Any) -> None:
+        """Report a skipped subtree as still mounted.
+
+        The prune at the end of a render deletes hook state for any slot it did
+        not see. A reused subtree is never walked, so without this its hooks --
+        and every hook under it -- would be collected and the component would
+        silently restart from its initial state on the next real render.
+        """
+        self._hooks_visited.add(slot_id)
+        beneath = self._subtree.get(slot_id, frozenset())
+        self._hooks_visited.update(beneath)
+        for ancestor in self._expanding:
+            self._subtree.setdefault(ancestor, set()).update(beneath)
+
+    def _expand(self, node: Any, path: str = "0") -> Any:
+        if isinstance(node, dict) and node.get("type") == "__Component__":
+            fn = node["fn"]
+            key = node.get("key")
+            slot_id = (id(fn), key if key is not None else path)
+            count = self._hooks_seen.get(slot_id, 0) + 1
+            self._hooks_seen[slot_id] = count
+            if count > 1:
+                raise ValueError(
+                    f"duplicate component key {key!r} for "
+                    f"{getattr(fn, '__name__', fn)}; keys must be unique "
+                    "per component within one render")
+            for ancestor in self._expanding:
+                self._subtree.setdefault(ancestor, set()).add(slot_id)
+
+            cached = self._reusable(slot_id, fn, node)
+            if cached is not None:
+                self._mark_reused(slot_id)
+                return cached
+
+            slots = self._hooks.setdefault(slot_id, [])
+            self._subtree[slot_id] = set()
+            self._expanding.append(slot_id)
+            frame = _hooks.enter(slots, lambda sid=slot_id: self._invalidate_slot(sid))
+            try:
+                try:
+                    expanded = fn(*node.get("args", ()), **node.get("kwargs", {}))
+                finally:
+                    arity_ok = (frame.index == len(slots)
+                                and frame.index == self._hooks_arity.setdefault(slot_id, frame.index))
+                    _hooks.exit()
+                if not arity_ok:
+                    raise RuntimeError(
+                        "hook count changed between renders: call hooks "
+                        "unconditionally in the same order every render")
+                self._hooks_visited.add(slot_id)
+                self._dirty_slots.discard(slot_id)
+                # Stays on the expanding stack across this call: children are
+                # expanded here, and each has to be recorded against every
+                # component above it or an ancestor cannot tell that something
+                # beneath it went stale.
+                result = self._expand(expanded, path)
+            finally:
+                self._expanding.pop()
+            self._effect_order.append(slot_id)
+            if self.memo and getattr(fn, "_flyrail_pure", False):
+                self._memo[slot_id] = (node.get("args", ()),
+                                       node.get("kwargs", {}), result)
+                self._memo_root_by_id[id(result)] = slot_id
+            return result
+        if isinstance(node, dict):
+            out = dict(node)
+            children = out.get("children")
+            if isinstance(children, list):
+                out["children"] = [self._expand(c, f"{path}.{i}")
+                                   for i, c in enumerate(children)]
+            return out
+        if isinstance(node, list):
+            return [self._expand(c, f"{path}.{i}") for i, c in enumerate(node)]
+        return node
+
+    def _serialize(self, node: Any, path: str, collected: dict) -> Any:
+        """Serialize a subtree, reusing the last result at a memoised root.
+
+        Serialization rebuilds every node carrying a handler, so a subtree that
+        _expand handed back untouched still came out as fresh objects and the
+        tree was never identical twice. At a memoised root the answer is
+        already known: same expanded input, same path, same output. The path
+        has to match because handler ids are built from it.
+
+        The registry is still rebuilt from scratch every render -- the ids have
+        to stay resolvable -- so a cache hit replays the subtree's
+        registrations rather than skipping them.
+        """
+        slot_id = self._memo_root_by_id.get(id(node)) if isinstance(node, dict) else None
+        if slot_id is None:
+            return self._serialize_node(node, path, collected)
+
+        cached = self._serial.get(slot_id)
+        if cached is not None and cached[0] is node and cached[1] == path:
+            collected.update(cached[3])
+            return cached[2]
+
+        own: dict[str, Callable] = {}
+        out = self._serialize_node(node, path, own)
+        self._serial[slot_id] = (node, path, out, own)
+        collected.update(own)
+        return out
+
+    def _serialize_node(self, node: Any, path: str, collected: dict) -> Any:
+        """Swap callables for {"handlerId": ...}, returning a new node only
+        where something actually changed.
+
+        This used to mutate a deep copy of the whole tree. Copying every node
+        to rewrite the few that carry handlers cost more than the diff did, and
+        a subtree that is reused across renders must not be written through at
+        all. Rebuilding only the nodes that change keeps untouched subtrees
+        identical, which is what lets a caller skip work on them.
+        """
+        if not isinstance(node, dict):
+            return node
+
+        key = node.get("key", "")
+        replaced: dict[str, Any] = {}
+        for evt in ("on_click", "on_change"):
+            fn = node.get(evt)
+            if callable(fn):
+                # The path is built from keys where children have them, so a
+                # widget keeps its id when its siblings move around it.
+                hid = f"{path}:{evt}:{key}"
+                collected[hid] = fn
+                replaced[evt] = {"handlerId": hid,
+                                 **{**EVENT_DEFAULTS,
+                                    **node.get("event_options", {}).get(evt, {})}}
+
+        children = node.get("children")
+        serialized_children = None
+        if isinstance(children, list):
+            walked = [self._serialize(child, f"{path}.{_segment(child, i)}", collected)
+                      for i, child in enumerate(children)]
+            if any(a is not b for a, b in zip(walked, children)):
+                serialized_children = walked
+
+        if not replaced and serialized_children is None:
+            return node
+
+        out = dict(node)
+        out.update(replaced)
+        if serialized_children is not None:
+            out["children"] = serialized_children
+        return out
+
+    def _check_allowlist(self, node: Any) -> None:
+        if isinstance(node, dict):
+            t = node.get("type")
+            if t not in ("__Slot__",) and t not in (self.allowed_types or set()):
+                raise ValueError(f"node type {t!r} not in allowlist")
+            for c in node.get("children", []) or []:
+                self._check_allowlist(c)
+
+    def diff_and_commit(self, tree: dict) -> list[dict]:
+        """Ops for what changed, or [] when nothing did.
+
+        Three gates, cheapest first. A memoised render hands back the very
+        same tree object, so identity settles it outright. Otherwise the
+        previous tree has to be kept anyway to diff against, so comparing it is
+        cheaper than serialising and hashing it -- and cannot collide, which a
+        digest over json.dumps(default=str) can: two values that stringify
+        alike hashed alike and the update was silently dropped.
+        """
+        if tree is self._last_source:
+            return []
+        if self._last_tree is not None and _unchanged(self._last_tree, tree):
+            self._last_source = tree
+            return []
+        old = self._last_tree if self._last_tree is not None else {}
+        ops = _diff(old, tree, path="", keyed_lists=self.keyed_lists)
+        self._last_tree = copy.deepcopy(tree)
+        self._last_source = tree
+        return ops
+
+    def tick(self, state: Any, version: Any = None) -> list[dict]:
+        """Render + diff. Pure renders skip render CPU when the host version
+        matches the last rendered version and nothing invalidated since.
+        Unmarked renders always re-render (correct by default)."""
+        if (version is not None
+                and version == self._version
+                and not self._dirty
+                and getattr(self.render_fn, "_flyrail_pure", False)):
+            return []
+        tree = self.render(state)
+        self._version = version
+        return self.diff_and_commit(tree)
+
+    def snapshot(self, state: Any, seq: int) -> dict:
+        """Full-tree recovery message answering a client resync-request.
+
+        Re-renders, re-registers handlers, and resets the diff baseline so
+        subsequent ticks stay incremental from the snapshot point.
+        """
+        tree = self.render(state)
+        self._last_tree = copy.deepcopy(tree)
+        self._last_source = tree
+        return {"chan": "ui", "type": "snapshot", "seq": seq, "tree": tree}
+
+    def dispatch(self, handler_id: str, state: Any, event: Any = None) -> None:
+        """Run a sync handler; refuse an async one.
+
+        Two different author mistakes used to give the same message. A handler
+        that *is* async is caught on the function, before a throwaway coroutine
+        is built; a sync handler that *returns* an awaitable can only be caught
+        after calling it, and its synchronous part has necessarily already run.
+        Saying which happened is the difference between "use adispatch" and
+        "you have a half-applied handler".
+        """
+        fn = self.registry.get(handler_id)
+        if fn is None:
+            raise KeyError(f"unknown handler {handler_id!r}")
+        if _is_async(fn):
+            raise RuntimeError(
+                f"handler {handler_id!r} is async; use await adispatch() "
+                "instead of dispatch()")
+        res = fn(state, event)
+        if inspect.isawaitable(res):
+            # A sync function that returns an awaitable: nothing of the
+            # awaitable has run, so closing it really does cancel it.
+            if inspect.iscoroutine(res):
+                res.close()
+            raise RuntimeError(
+                f"handler {handler_id!r} returned an awaitable; use await "
+                "adispatch() instead of dispatch()")
+
+    async def adispatch(self, handler_id: str, state: Any, event: Any = None) -> Any:
+        """Dispatch both sync and async handlers; awaits awaitables.
+        Async-host pattern: await layout.adispatch(...) then invalidate()."""
+        fn = self.registry.get(handler_id)
+        if fn is None:
+            raise KeyError(f"unknown handler {handler_id!r}")
+        res = fn(state, event)
+        if inspect.isawaitable(res):
+            res = await res
+        return res
+
+    def set_slot(self, name: str, value: Any) -> dict | None:
+        """Hot path bypassing the diff: unchanged values return None.
+
+        Compared, not hashed, for the same reason as the tree: the last value
+        is kept regardless, so the digest bought nothing and could collide.
+        """
+        if name in self._slots and _unchanged(self._slots[name], value):
+            return None
+        self._slots[name] = value
+        return {"chan": "ui", "type": "slot", "name": name, "value": value}

flyrail/transport.py

@@ -0,0 +1,26 @@
+"""Optional FastAPI helper. Skip it if you have your own socket/tick."""
+from __future__ import annotations
+from typing import Any
+
+
+def ui_envelope_patch(ops: list, seq: int) -> dict:
+    return {"chan": "ui", "type": "patch", "seq": seq, "ops": ops}
+
+
+FASTAPI_EXAMPLE = '''
+# tick integration sketch (your loop owns timing):
+from flyrail import Layout
+layout = Layout(MyPanel().render, allowed_types={"Stack","Text","Button","TextField"})
+seq = 0
+def on_tick(state):
+    global seq
+    ops = layout.tick(state)  # [] when unchanged
+    if ops:
+        seq += 1
+        broadcast(ui_envelope_patch(ops, seq))
+
+# your existing ws handler:
+async def on_ws_msg(msg, state):
+    if msg.get("chan") == "ui" and msg.get("type") == "action":
+        layout.dispatch(msg["handlerId"], state, msg.get("event"))
+'''

flyrail-0.1.0.dist-info/METADATA

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: flyrail
+Version: 0.1.0
+Summary: Bring-your-own-frontend server-driven UI core (reactpy-style API, transport agnostic)
+Author-email: Aaron Lipinski <kris.lipinski@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/krisl/flyrail
+Project-URL: Repository, https://github.com/krisl/flyrail
+Keywords: ui,server-driven-ui,websocket,asgi
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: AsyncIO
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# flyrail
+
+Bring-your-own-frontend server-driven UI with a reactpy-style Python API.
+Python declares the UI, your React+MUI app renders it, your socket carries
+it, your tick drives it.
+
+## Why this exists
+
+`reactpy` owns the whole React tree and its own socket protocol. `rjsf`
+owns form rendering but not arbitrary layouts. flyrail splits the problem:
+
+- **Python** (`flyrail/`): declarative element helpers, per-session handler
+  registry, per-component memoisation, gated keyed-list diffing, slot
+  fast-path. Zero dependencies.
+- **JS** (`js/`, `flyrail-renderer`): namespace component registry
+  (`import * as MUI`), patch applier, client store with resync, debounced
+  inputs. Zero dependencies (React is a peer).
+
+See [docs/features.md](docs/features.md) for what each capability buys you,
+with a runnable example each.
+
+## Message flow
+
+```
+tick:   render(state) -> tree -> diff -> [] | patch ops -> {chan:ui,type:patch,seq,ops}
+click:  {chan:ui,type:action,handlerId,event?} -> dispatch -> mutate state -> next tick emits
+hot:    set_slot(name, value) -> {chan:ui,type:slot} (bypasses diff)
+gap:    seq skip -> resync-request -> snapshot(state, seq) -> {chan:ui,type:snapshot,tree}
+```
+
+## Python quickstart
+
+```python
+from flyrail import Layout, Stack, Text, Button
+from flyrail.transport import ui_envelope_patch
+
+class Panel:
+    def render(self, s):
+        return Stack(
+            Text(f"speed: {s.speed}"),
+            Button("Stop", on_click=self.stop),  # like reactpy
+        )
+    def stop(self, state, event):
+        state.speed = 0
+
+layout = Layout(Panel().render, allowed_types={"Stack", "Text", "Button"})
+seq = 0
+def on_tick(state):
+    global seq
+    if ops := layout.tick(state):  # [] on idle ticks: send nothing
+        seq += 1
+        broadcast(ui_envelope_patch(ops, seq))
+
+def on_ws(msg, state):
+    if msg.get("chan") == "ui" and msg.get("type") == "action":
+        layout.dispatch(msg["handlerId"], state, msg.get("event"))
+    elif msg.get("type") == "resync-request":
+        broadcast(layout.snapshot(state, seq + 1))
+```
+
+## JS quickstart
+
+```tsx
+import * as MUI from '@mui/material';
+import { createRenderer } from 'flyrail-renderer';
+import { createStore } from 'flyrail-renderer/store';
+
+const { ServerNode } = createRenderer({ ...MUI });  // auto-registered, no switch
+const store = createStore({ onResync: (req) => ws.send(JSON.stringify(req)) });
+ws.onmessage = (e) => store.ingest(JSON.parse(e.data));
+// render store.getTree() via <ServerNode node={tree} send={...} />
+```
+
+## Hosting (pick one)
+
+```python
+# 1. Fixed tick you own: Driver replaces the hand-rolled seq counter.
+from flyrail import Driver
+driver = Driver(layout)
+def on_tick(state, version):
+    if env := driver.flush(state, version):
+        broadcast(env)
+
+# 2. Async host: raw ASGI app, one session per connection. FastAPI:
+#    from fastapi import WebSocket; await create_ws_app(Panel().render)(scope, receive, send)
+#    (or mount in any ASGI framework; no fastapi dependency in this package)
+from flyrail import create_ws_app
+app = create_ws_app(Panel().render, state_factory=Sim,
+                    on_message=lambda data, state: handle_telemetry(data))
+
+# 3. Naive host (no loop at all): invalidate + flush around every message.
+driver.invalidate()
+if env := driver.flush(state):
+    send(env)
+```
+
+## Best practices
+
+1. **Stable keys, never indexes.** `key=item.id` on every list child, both
+   sides: Python handler ids embed the key, React reconciles by it. Reorder
+   without keys = full remount + lost focus. Keys must be unique among
+   siblings: duplicates share one handler id (last registration wins) and
+   components reject them, plain nodes do not.
+2. **Slots for tick-rate values.** Table rows, labels, progress: `Slot("rows")`
+   + `set_slot()` bypass the tree diff. Structure goes through patches (rare),
+   values through slots (every tick).
+3. **Allowlist both ends.** Python `allowed_types={...}` rejects unknown node
+   types; JS `isKnownComponent` renders only functions (filters MUI's
+   `colors`, `createTheme`, etc.). Never render `registry[arbitraryString]`.
+4. **One render per tick, send only on change.** `tick()` then `if ops:`.
+   Hash-gating makes idle ticks free.
+5. **Inputs debounce client-side** (150ms default). Server never sees
+   keystroke storms; use `flush()` on submit.
+6. **Caller-owned seq, snapshot on gaps.** The tick loop numbers patches; the
+   store drops stale/duplicates and answers gaps with one snapshot round-trip.
+7. **Keep `render(state)` pure and cheap.** No DB, no IO: derive from the
+   already-computed tick state. One `Layout` per session.
+8. **Safe event defaults, names like the DOM.** `preventDefault` is true
+   unless opted out (a reload is session death); `stopPropagation` stays
+   opt-in; `throttleMs` rate-caps sliders and guards double-submit. Same
+   names as the browser, defaults chosen for the socket.
+9. **Mark renders `@pure`, version host state.** Pure renders skip render
+   CPU when the version is unchanged (unmarked always re-render: correct by
+   default). `strict=True` double-renders in dev to catch nondeterminism.
+10. **Component-local UI state via hooks.** `use_state`/`use_memo` inside
+    `@component` bodies keeps collapsed flags and drafts out of tick state;
+    setters schedule through `invalidate()`. Distinct `key=` per instance,
+    hooks unconditional and order-stable, or it raises loudly. Effect
+    cleanups that raise abort the render instead of being swallowed.
+11. **Async handlers via `adispatch`.** Handlers may be `async def` (e.g.
+    `await db.save()` on click); sync `dispatch` refuses them loudly instead
+    of silently dropping the coroutine. Pattern: `await adispatch(...)`,
+    then `invalidate()`.
+
+## Docs
+
+- [How it works](docs/how-it-works.md) — architecture, tick/action/resync
+  sequences, render pipeline, hook slots, scheduling, message catalog.
+
+## Layout
+
+```
+flyrail/          Python core (stdlib only)
+  core.py         Stack/Text/Button/TextField/Slot, @component, @pure
+  hooks.py        use_state/use_memo keyed slots
+  layout.py       registry + diff + dispatch + slots + snapshot
+  driver.py       dirty-flag scheduling for tick/async/naive hosts
+  asgi.py         framework-free websocket sessions
+  transport.py    multiplex envelope + tick sketch
+js/               flyrail-renderer (zero-dep ESM + tsx)
+  protocol.mjs    envelopes, applyOps, debounce (node-tested)
+  store.mjs       seq tracking, gap->resync, slots (node-tested)
+  ServerNode.tsx  MUI-bound renderer (imports protocol.mjs)
+example/          hmi_demo.py runnable narrative of the wire
+tests/            focused unittest suites + public-API loopback
+```
+
+## Tests
+
+```
+PYTHONPATH=. python3 -m unittest discover -s tests -v   # 67 tests
+node --test js/protocol.test.mjs js/store.test.mjs      # 24 tests
+PYTHONPATH=. python3 example/hmi_demo.py                 # narrated wire demo
+```
+
+## Non-goals / roadmap
+
+- Not a form validator (use your backend validation + error slots), not a
+  JSON-Schema renderer (see rjsf), not a full reactpy replacement (sync
+  core with no async effects; bring your own frontend instead of an
+  owned tree).
+- Roadmap: vitest + React Testing Library for `ServerNode`, `byId/order`
+  maps for huge reorderable lists, keystroke `ackSeq` if loss-less input sync
+  is ever needed, registry packaging.

flyrail-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+flyrail/__init__.py,sha256=9iftclITtzY_F9dlbFveQ6aNrG2zO1r483jMy5xBHAo,615
+flyrail/asgi.py,sha256=SmNXYRZoi8sQQ5gduSreDemmjJtv-o5fZSiE6xk8te8,2789
+flyrail/core.py,sha256=b9h6hiJVwf8SnMjOwK7Z9FzGFs2_EhaUBN8OfJtCvUM,4112
+flyrail/driver.py,sha256=jSP76d82Y4V3QC1eKTh3JkqqfcAZGWAbtykpbMAxkMs,1883
+flyrail/hooks.py,sha256=j44bF7VcF3O4-64DkH7Amh2gQQAdWj3Q94LcTEcJyiY,5697
+flyrail/layout.py,sha256=ke0fn4ac7ZMprmzJoAf_EgSEDZJH67woyEy6MekbuF0,25704
+flyrail/transport.py,sha256=4r4b5zlnG02URR6CwnMfdrKJajjo5vMgFw5JWRlI7E0,807
+flyrail-0.1.0.dist-info/licenses/LICENSE,sha256=DXMteL9cssAvP5kfNKN3eo0P0g0tB5qzopMPZBNz6EY,1071
+flyrail-0.1.0.dist-info/METADATA,sha256=rQickIxA3aaMr6R9Ui2LYXZD3E5x2SCBXePDYzpDO8w,7987
+flyrail-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+flyrail-0.1.0.dist-info/top_level.txt,sha256=64sQe8W-UPujoM0JwigoePakZqIUiwDtoKynpGvq--A,8
+flyrail-0.1.0.dist-info/RECORD,,

flyrail-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
+

flyrail-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aaron Lipinski
+
+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.

flyrail-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+flyrail