beatrina 0.8.6

package/engines/python/worker.py

@@ -0,0 +1,564 @@
+#!/usr/bin/env python3
+"""worker.py — the Python engine, speaking the same wire as `spike/worker.R`.
+
+Beatrix's host (`host/worker-plane.mjs`) is engine-neutral: it owns wire ids, a
+single-flight queue, deadlines, the interrupt ladder and respawn, and it talks
+to an ENGINE ADAPTER. `host/engine-python.mjs` is this engine's adapter; this
+file is the process behind it, and everything it says is a frame in the shape
+`docs/worker-protocol.md` §3.1 records for R.
+
+    stdin   `#<cmdtag> {json}\\n`  — one command per line; a comment, so a line
+                                    that ever reached a raw prompt is inert.
+                                    Over 32,000 bytes it is a `cmdfile`.
+    stdout  `<sentinel>{json}\\n`  — one control frame per line.
+    SIGINT  to this process's group — Stop.
+
+WHY SIGINT AND NOT A COMMAND. jupyter_client starts the ipykernel in its OWN
+session (measured 2026-09-14 on this machine: kernel sid == kernel pid), so the
+host's group signal reaches THIS process and not the kernel. That is the
+arrangement we want: a signal cannot be queued behind a running cell the way a
+stdin command can, and this process is never the one evaluating, so it is
+always free to catch it and forward `interrupt_request` to the kernel.
+
+WHAT THIS PROCESS NEVER DOES. It does not evaluate user code — the ipykernel
+does, one process further out. It does not open a port (the kernel's own ZMQ
+sockets are jupyter_client's, on loopback, and are not Beatrix's wire). It does
+not interpret chunk options; the host coordinates, the engine executes.
+
+Ported from `../carmar-python/py/carmapy/` — `adapter.py` from
+`kernel_adapter.py`, `bootstrap.py`, `dataview.py` and `document_exec.py`
+verbatim or nearly so. That repository is read-only to this one.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import signal
+import sys
+import threading
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from adapter import PythonSession                      # noqa: E402
+from document_exec import (DocumentExecError,          # noqa: E402
+                           DocumentSetups, FEATURE)
+
+SENTINEL = os.environ.get("CARMAR_SENTINEL", "")
+CMD_TAG = os.environ.get("CARMAR_CMD_TAG", "")
+KERNEL_NAME = os.environ.get("CARMAR_PYTHON_KERNEL", "python3")
+
+#: Every verb this engine answers. The host merges it into `ready.commands`,
+#: and `lib/kernel-capability.js` is the reason it matters: an op a kernel
+#: never advertised is refused BY NAME instead of waiting on silence.
+COMMANDS = [
+    "exec", "view", "colstats", "env", "rm", "complete", "parse", "wd",
+    "doctor", "input_reply", "interrupt", "shutdown",
+    # The debugger (docs/wp/wp8b-python-debugger.md): breakpoints by chunk
+    # srcname and line, and the step commands of a paused chunk.
+    "debug_breaks", "debug_cmd",
+]
+
+#: The step commands a paused chunk understands — lib/debugger.js's and
+#: lib/console.js's vocabulary, the same words R's plane maps to browser() keys.
+DEBUG_ACTIONS = ("continue", "over", "into", "out", "where", "abort", "eval")
+
+#: Claimed on `ready`. `document_exec_v1` is what `verbs.js` requires before it
+#: will run any chunk at all, and `document_exec.py` implements the subset of
+#: `knitr-run.R` that is not knitr (see its docstring for what is NOT kept).
+FEATURES = [FEATURE]
+
+_write_lock = threading.Lock()
+
+
+def emit(frame: dict) -> None:
+    """One control frame, on its own line, behind the session's sentinel.
+
+    `allow_nan=False` on purpose: `NaN` and `Infinity` are not JSON and
+    `JSON.parse` rejects them, so a frame carrying one would reach the page as
+    a parse failure rather than as a number. Every payload that can hold a
+    float has already mapped them to null (dataview's `_num`); this is the
+    backstop that makes a miss loud here instead of silent there.
+
+    COMPACT, and that is a wire requirement, not a taste. `relayFrame` in
+    host/worker-plane.mjs rewrites the routing id INSIDE the engine's original
+    bytes — it searches for the literal `"id":"wire-7"` so the rest of the
+    frame is never re-encoded (re-encoding is what rounded 1.2345e-05 to 0 in
+    serve.R). Python's default `json.dumps` writes `"id": "wire-7"`, with a
+    space, which that search does not find; measured 2026-09-14, every frame of
+    the first Python chunk reached the page addressed to `wire-1`, and the page
+    dropped all of them. jsonlite writes compact, so R never showed it.
+    """
+    try:
+        line = SENTINEL + json.dumps(frame, allow_nan=False, default=str,
+                                     separators=(",", ":")) + "\n"
+    except (ValueError, TypeError) as exc:
+        line = SENTINEL + json.dumps(
+            {"type": frame.get("type", "error"), "id": frame.get("id"),
+             "error": f"this engine produced a frame that is not JSON: {exc}"},
+            separators=(",", ":")) + "\n"
+    with _write_lock:
+        sys.stdout.write(line)
+        sys.stdout.flush()
+
+
+class Worker:
+    def __init__(self) -> None:
+        self.session: PythonSession | None = None
+        self.docs = DocumentSetups()
+        self.queue: asyncio.Queue = asyncio.Queue()
+        self.loop: asyncio.AbstractEventLoop | None = None
+        self.stopping = False
+        #: srcname -> sorted 1-based lines. Held HERE, in the process that is
+        #: never busy, so a breakpoint toggled while a chunk runs is recorded
+        #: at once; it reaches the kernel with the next run, or with the next
+        #: command of a pause.
+        self.breaks: dict[str, list[int]] = {}
+
+    # ── boot ────────────────────────────────────────────────────────────────
+
+    async def start(self) -> None:
+        self.loop = asyncio.get_running_loop()
+        self.session = PythonSession(kernel_name=KERNEL_NAME, on_input=self._ask_input,
+                                     on_debug=self._debug_prompt)
+        info = await self.session.start()
+        emit({
+            "type": "ready",
+            # The pid the HOST supervises, which is this process — not the
+            # ipykernel's. The plane's respawn watches this process's exit, and
+            # a test that kills `ready.pid` must kill the thing that comes back.
+            "pid": os.getpid(),
+            "kernel_pid": info.get("pid"),
+            "python": info.get("python"),
+            "language": "python",
+            "language_version": info.get("python"),
+            "engines": ["python"],
+            "executable": info.get("executable"),
+            "cwd": info.get("cwd"),
+            "home": os.path.expanduser("~"),
+            "libs": [p for p in sys.path if p],
+            # `interactive` is the mode word the plane reads for "this engine
+            # can answer a question while a cell runs" (input_reply) — and,
+            # as for R's interactive worker, it has a debugger
+            # (debug_breaks/debug_cmd in COMMANDS, canDebug in the adapter).
+            "mode": "interactive",
+            "features": FEATURES,
+            "commands": COMMANDS,
+        })
+
+    # ── the command reader ──────────────────────────────────────────────────
+
+    def read_stdin(self) -> None:
+        """A THREAD, not the loop. `input_reply` and `interrupt` must be read
+        while a chunk is running, and a blocking readline on the loop would
+        make Stop a lie one process further in — the same argument that put
+        the supervisor and the worker in different processes."""
+        tag = f"#{CMD_TAG} " if CMD_TAG else None
+        while True:
+            line = sys.stdin.readline()
+            if not line:
+                break
+            line = line.strip()
+            if not line:
+                continue
+            if tag and line.startswith(tag):
+                line = line[len(tag):]
+            elif tag and line.startswith("#"):
+                continue                      # a comment that is not ours
+            try:
+                cmd = json.loads(line)
+            except Exception:
+                continue
+            if not isinstance(cmd, dict) or not isinstance(cmd.get("type"), str):
+                continue
+            if cmd["type"] == "cmdfile":
+                cmd = self._read_cmdfile(cmd.get("path"))
+                if cmd is None:
+                    continue
+            self._accept(cmd)
+        if self.loop is not None:
+            self.loop.call_soon_threadsafe(self._eof)
+
+    @staticmethod
+    def _read_cmdfile(path):
+        """A command past the console-line limit, delivered through a 0600 file.
+
+        Read, deleted, dispatched — and never accepted from a page: the host
+        writes these itself (`host/engine-stdio.mjs`), the browser cannot.
+        """
+        if not isinstance(path, str) or not path:
+            return None
+        try:
+            with open(path, "r", encoding="utf-8") as fh:
+                cmd = json.loads(fh.read())
+        except Exception:
+            return None
+        finally:
+            try:
+                os.unlink(path)
+            except OSError:
+                pass
+        return cmd if isinstance(cmd, dict) and isinstance(cmd.get("type"), str) else None
+
+    def _accept(self, cmd: dict) -> None:
+        """Decide, on the READER's thread, whether this command may jump the
+        queue. Two may: an answer to a question the kernel is already asking,
+        and a Stop. Everything else is work, and work is serial."""
+        kind = cmd["type"]
+        if kind in ("input_reply", "interrupt", "shutdown", "debug_cmd", "debug_breaks"):
+            self.loop.call_soon_threadsafe(self._urgent, cmd)
+        else:
+            self.loop.call_soon_threadsafe(self.queue.put_nowait, cmd)
+
+    def _urgent(self, cmd: dict) -> None:
+        kind = cmd["type"]
+        if kind == "input_reply":
+            value = cmd.get("value")
+            running = self.session.current if self.session else None
+            if isinstance(value, str) and self.session and self.session.answer_input(value):
+                emit({"type": "input_done", "id": running})
+            return
+        if kind == "interrupt":
+            self.on_interrupt()
+            return
+        if kind == "debug_breaks":
+            self.set_breaks(cmd)
+            return
+        if kind == "debug_cmd":
+            action = cmd.get("action")
+            expr = cmd.get("expr")
+            if action not in DEBUG_ACTIONS or (action == "eval" and not isinstance(expr, str)):
+                return
+            if self.session is not None:
+                self.session.answer_debug({"action": action, "expr": expr if action == "eval" else None,
+                                           "breaks": self.breaks})
+            return
+        if kind == "shutdown":
+            self.stopping = True
+            self.loop.create_task(self._shutdown())
+
+    def _eof(self) -> None:
+        """The host closed our stdin: it is gone, and so are we."""
+        self.stopping = True
+        self.loop.create_task(self._shutdown())
+
+    async def _shutdown(self) -> None:
+        if self.session:
+            await self.session.shutdown()
+        # os._exit, not sys.exit: an asyncio task raising SystemExit inside a
+        # running loop is caught by the loop, and the process would linger with
+        # its kernel already gone.
+        sys.stdout.flush()
+        os._exit(0)
+
+    # ── Stop ────────────────────────────────────────────────────────────────
+
+    def on_interrupt(self, *_a) -> None:
+        """SIGINT reached THIS process. Forward it to the kernel.
+
+        Scheduled onto the loop rather than awaited here: a signal handler runs
+        between bytecodes and `interrupt_kernel` is a coroutine. Nothing else
+        happens — this process has nothing of its own to interrupt.
+        """
+        if self.session is None or self.loop is None:
+            return
+        # A Stop THIS worker forwarded, recorded against the run that is going.
+        # ipykernel does not always say "KeyboardInterrupt" in a shape that can
+        # be told from user output (see adapter._translate), so the fact that
+        # Stop was pressed during this run is the reliable half; the shell
+        # reply's non-ok status is the other half, and both are required.
+        if self.session.current is not None:
+            self.session.interrupted = True
+        self.loop.call_soon_threadsafe(
+            lambda: self.loop.create_task(self._interrupt()))
+
+    async def _interrupt(self) -> None:
+        try:
+            await self.session.interrupt()
+        except Exception as exc:
+            emit({"type": "stream", "kind": "warning",
+                  "text": f"Beatrina could not interrupt the Python kernel: {exc}"})
+
+    async def _ask_input(self, prompt: str, wire_id) -> None:
+        emit({"type": "input_request", "id": wire_id, "prompt": prompt})
+
+    # ── the debugger ────────────────────────────────────────────────────────
+
+    def set_breaks(self, cmd: dict) -> None:
+        """`debug_breaks {file, lines}` — spike/worker.R `emit_debug_breaks`.
+
+        Same validation, same reply shape (`file`, `lines`), answered at once:
+        the registry lives in this process, not in the kernel, so there is no
+        queue to wait behind. `functions` — R's count of armed function traces
+        — is ABSENT: a Python breakpoint addresses every function the chunk
+        defined by the code's own filename, and there is no count to report.
+        """
+        wire = cmd.get("id")
+        file = cmd.get("file")
+        if not isinstance(file, str) or not file:
+            if wire is not None:
+                emit({"type": "debug_breaks", "id": wire, "error": "bad file"})
+            return
+        raw = cmd.get("lines")
+        raw = raw if isinstance(raw, list) else ([] if raw is None else [raw])
+        lines = []
+        for x in raw:
+            try:
+                n = int(x)
+            except (TypeError, ValueError):
+                continue
+            if n >= 1 and n not in lines:
+                lines.append(n)
+        lines.sort()
+        if lines:
+            self.breaks[file] = lines
+        else:
+            self.breaks.pop(file, None)
+        if wire is not None:
+            emit({"type": "debug_breaks", "id": wire, "file": file, "lines": lines})
+
+    async def _debug_prompt(self, payload: str, wire_id) -> None:
+        """The paused chunk's prompt. `paused` and `where` become the `debug`
+        frame R emits (no id: the plane addresses it to the run that owns the
+        slot, as it does R's); a bare re-prompt after an `eval` says nothing,
+        because R's Browse prompt coming back says nothing either."""
+        try:
+            state = json.loads(payload)
+        except Exception:
+            return
+        if not isinstance(state, dict) or state.get("event") not in ("paused", "where"):
+            return
+        frame = {"type": "debug", "event": state["event"]}
+        for key in ("file", "line", "reason", "stack", "locals"):
+            if state.get(key) is not None:
+                frame[key] = state[key]
+        emit(frame)
+
+    # ── the work loop ───────────────────────────────────────────────────────
+
+    async def run(self) -> None:
+        while not self.stopping:
+            cmd = await self.queue.get()
+            try:
+                await self.dispatch(cmd)
+            except Exception as exc:                # never lose the loop
+                wire = cmd.get("id")
+                if cmd.get("type") == "exec":
+                    emit({"type": "done", "id": wire, "status": "error",
+                          "message": f"{type(exc).__name__}: {exc}",
+                          "cwd": self.cwd()})
+                elif wire is not None:
+                    emit({"type": cmd.get("type"), "id": wire,
+                          "error": f"{type(exc).__name__}: {exc}"})
+
+    def cwd(self) -> str:
+        return (self.session.cwd if self.session else "") or os.getcwd()
+
+    async def dispatch(self, cmd: dict) -> None:
+        kind = cmd["type"]
+        wire = cmd.get("id")
+        if kind == "exec":
+            return await self.exec(cmd)
+        if kind in ("view", "colstats", "env", "rm"):
+            spec = {k: v for k, v in cmd.items() if k not in ("type", "id", "engine")}
+            answer = await self.session.request(kind, spec)
+            return emit({"type": kind, "id": wire, **answer})
+        if kind == "complete":
+            line = cmd.get("line") or ""
+            cursor = cmd.get("cursor")
+            cursor = len(line) if not isinstance(cursor, int) else cursor
+            answer = await self.session.complete(line, cursor)
+            if answer is None:
+                # BUSY, not broken. The page backs off and retries; an error
+                # here would latch completion off for the rest of the session.
+                return emit({"type": "complete", "id": wire, "busy": True,
+                             "start": cursor, "end": cursor, "matches": []})
+            return emit({"type": "complete", "id": wire, **answer})
+        if kind == "parse":
+            return emit({"type": "parse", "id": wire, **_parse_state(cmd.get("source"))})
+        if kind == "wd":
+            path = cmd.get("path")
+            if isinstance(path, str) and path:
+                await self.session.execute(
+                    f"import os as _os; _os.chdir({path!r})", "wd", None,
+                    store_history=False, allow_stdin=False)
+            return emit({"type": "wd", "id": wire, "path": self.cwd()})
+        if kind == "doctor":
+            return emit({"type": "doctor", "id": wire, **self.doctor()})
+        # An unknown type falls off the end SILENTLY, exactly as worker.R's
+        # dispatch chain does — which is why the plane has per-class deadlines
+        # and why `commands` above is the contract.
+        return None
+
+    def doctor(self) -> dict:
+        import platform
+        return {
+            "language": "python", "version": sys.version.split()[0],
+            "executable": sys.executable, "prefix": sys.prefix,
+            "kernel": KERNEL_NAME, "platform": platform.platform(),
+            "cwd": self.cwd(), "path": [p for p in sys.path if p],
+        }
+
+    # ── exec ────────────────────────────────────────────────────────────────
+
+    async def exec(self, cmd: dict) -> None:
+        wire = cmd.get("id")
+        source = cmd.get("source", cmd.get("code", ""))
+        if not isinstance(source, str):
+            return emit({"type": "done", "id": wire, "status": "error",
+                         "message": "no source", "cwd": self.cwd()})
+        engine = cmd.get("engine")
+        if engine is not None and str(engine).lower() not in ("python", "py"):
+            # THE SECOND LOCK. The page refuses a chunk whose engine the host
+            # has no runtime for, and the engine refuses it again, so a page
+            # patched wrong cannot run an R chunk in a Python session.
+            return emit({"type": "done", "id": wire, "status": "error",
+                         "message": f"This engine runs python; it was asked to "
+                                    f"run a {engine} chunk.", "cwd": self.cwd()})
+
+        async def out(frame):
+            emit(frame)
+
+        dims = cmd.get("dims")
+        self.session.dims = dims if isinstance(dims, dict) else None
+        document = cmd.get("document")
+        if document is not None:
+            return await self.exec_document(wire, source, document, out, srcname=_srcname(cmd))
+        self.progress(wire, source)
+        status = await self.session.execute(source, wire, out, srcname=_srcname(cmd),
+                                            breaks=self.breaks)
+        # `cwd` rides the done frame, as R's does: a chunk that called
+        # os.chdir() has finished, so this is the first moment the new value is
+        # certainly current.
+        emit({"type": "done", "id": wire, "status": status,
+              "message": self.session.failure, "cwd": self.cwd()})
+
+    @staticmethod
+    def progress(wire, source: str) -> None:
+        """ONE progress frame per chunk, and the honest reason it is one.
+
+        R emits one per top-level expression because its worker evaluates them
+        one at a time. ipykernel's `execute_request` is atomic — the chunk is
+        one unit, and splitting it would change what the notebook shows
+        (IPython displays the LAST expression's value, not every one), so a
+        per-expression count here would be a number this engine cannot know.
+        The frame is still sent so the editor's progress affordance is fed
+        rather than silent, and it says what is true: one unit, of one.
+        """
+        lines = source.count("\n") + 1
+        emit({"type": "progress", "id": wire, "index": 1, "total": 1,
+              "line": 1, "end": lines})
+
+    async def exec_document(self, wire, source: str, document, out, srcname=None) -> None:
+        """The notebook exec envelope — `document_exec_v1`, as the page sends it.
+
+        Port of `knitr-run.R`'s `run_document_cell()` minus knitr (see
+        document_exec.py for what is kept and what is not). The decisions are
+        `self.docs.plan`'s; this runs them: the `setup` frame, the setup chunk
+        with its output hidden and its tracebacks shown, the ledger update,
+        then the chunk, and ONE terminal `done` carrying `setup`, `cacheHit`,
+        `effectiveOptions`, `execution` and `cwd` exactly as R's does.
+        """
+        done = {"type": "done", "id": wire, "status": "ok", "message": None,
+                "setup": None, "cacheHit": False, "effectiveOptions": None}
+        try:
+            plan = self.docs.plan(source, document)
+        except DocumentExecError as err:
+            done.update(status="error", message=str(err), cwd=self.cwd())
+            return emit(done)
+        done["execution"] = plan.execution
+        if plan.run_setup:
+            # Invalidate BEFORE executing: a failed partial setup must never
+            # leave a previous Ready snapshot available to dependent chunks.
+            self.docs.setup_started(plan.doc_id)
+            report = {"source": plan.setup_source, "srcname": plan.setup_srcname,
+                      "status": "running"}
+            emit({"type": "setup", "id": wire, **report})
+            errors: list[dict] = []
+
+            async def emit_setup(frame):
+                # knitr `include = FALSE`: a setup's output is not shown; its
+                # failure is, so a failing setup says why. Both halves of a
+                # Python error reach the page — the traceback TEXT (`stderr`)
+                # and the `traceback` frame that carries its headline.
+                kind = frame.get("type")
+                if kind == "traceback":
+                    errors.append(frame)
+                    await out(frame)
+                elif kind == "stderr":
+                    await out(frame)
+
+            emit({"type": "progress", "id": wire, "index": 1, "total": 1,
+                  "line": 1, "end": plan.setup_source.count("\n") + 1,
+                  "phase": "setup"})
+            status = await self.session.execute(plan.setup_source, wire, emit_setup,
+                                                store_history=False)
+            why = (errors[-1].get("message") if errors else f"Chunk {status}")
+            if status != "ok":
+                self.docs.setup_failed(plan.doc_id, plan.setup_source)
+                report["status"] = status
+                done.update(status=status, setup=report, cwd=self.cwd(),
+                            message=f"Setup chunk failed; dependent chunk was "
+                                    f"not run. {why}")
+                return emit(done)
+            self.docs.setup_ok(plan.doc_id, plan.setup_source)
+            report["status"] = "ok"
+            done["setup"] = report
+        elif plan.setup_source is None:
+            self.docs.no_setup(plan.doc_id)
+        if plan.run_chunk:
+            self.progress(wire, source)
+            done["status"] = await self.session.execute(source, wire, out,
+                                                        srcname=srcname,
+                                                        breaks=self.breaks)
+            done["message"] = self.session.failure
+        done["cwd"] = self.cwd()
+        emit(done)
+
+
+def _srcname(cmd: dict):
+    """The chunk's debugging identity, or None. Wire-supplied; anything but a
+    plain non-empty string means "no identity", never an error (worker.R)."""
+    name = cmd.get("srcname")
+    return name if isinstance(name, str) and name else None
+
+
+def _parse_state(source) -> dict:
+    """Is this source a complete Python statement? Drives the console's
+    continuation prompt, exactly as `emit_parse` does for R: only the parser
+    knows whether more input would help."""
+    import codeop
+    if not isinstance(source, str):
+        source = ""
+    try:
+        # A trailing newline is what tells codeop a block is finished; without
+        # one `if x:\n  y` reads as "still open" forever.
+        result = codeop.compile_command(source + "\n", "<beatrina>", "exec")
+    except SyntaxError as exc:
+        return {"complete": True, "message": str(exc)}
+    except (ValueError, OverflowError) as exc:
+        return {"complete": True, "message": str(exc)}
+    return {"complete": result is not None, "message": None}
+
+
+async def main() -> None:
+    worker = Worker()
+    loop = asyncio.get_running_loop()
+    worker.loop = loop            # before the handlers, or an early signal has none
+    # add_signal_handler, not signal.signal: the C-level handler runs between
+    # bytecodes and cannot touch the loop safely.
+    loop.add_signal_handler(signal.SIGINT, worker.on_interrupt)
+    loop.add_signal_handler(signal.SIGTERM, worker._eof)
+    try:
+        await worker.start()
+    except Exception as exc:
+        emit({"type": "ready-error", "error": f"{type(exc).__name__}: {exc}"})
+        sys.stderr.write(f"beatrina python engine failed to start: {exc}\n")
+        os._exit(3)
+    threading.Thread(target=worker.read_stdin, daemon=True).start()
+    await worker.run()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/engines/r/engine.json

@@ -0,0 +1,25 @@
+{
+  "name": "r",
+  "label": "R",
+  "language": "r",
+  "fences": ["r", "R"],
+  "adapter": "host/engine-r.mjs",
+  "worker": "spike/worker-boot.R",
+  "runtime": {
+    "env": "CARMAR_RSCRIPT",
+    "ladder": [
+      "/Library/Frameworks/R.framework/Versions/Current/Resources/bin/Rscript",
+      "/opt/homebrew/bin/Rscript",
+      "/usr/local/bin/Rscript",
+      "/opt/local/bin/Rscript",
+      "/usr/bin/Rscript",
+      "PATH"
+    ]
+  },
+  "controls": {
+    "interrupt": "signal:SIGINT:group",
+    "console": "stdin:raw-line",
+    "commands": "stdin:tagged-json"
+  },
+  "note": "The worker files stay in spike/ until spike/serve.R retires (host-plan WP7); the manifest points at them so upstream merges stay trivial."
+}