흘러오는 동안 파싱하는 펜스 블록

역 출구 표지판이야. 중앙 출구는 오른쪽 아래 작은 글씨고.
```spark
{"type": "line", "n": 1, "source": "出口", "translation": "출구", "language": "ja-JP", "translation_language": "ko-KR"}
{"type": "line", "n": 2, "source": "Exit", "translation": "출구", "language": "en", "translation_language": "ko-KR", "note": "같은 표지판의 영어 표기"}
{"type": "line", "n": 3, "source": "中央口", "translation": "중앙 출구", "pronunciation": "추오구치", "language": "ja-JP", "translation_language": "ko-KR"}
{"type": "expression", "source": "中央口はどこですか？", "translation": "중앙 출구가 어디예요?", "pronunciation": "추오구치와 도코데스카", "use": "길을 물을 때", "language": "ja-JP", "translation_language": "ko-KR"}
```

    def feed(self, text: str) -> list[dict[str, Any]]:
        self._buffer += text
        found: list[dict[str, Any]] = []
        while "\n" in self._buffer:
            line, self._buffer = self._buffer.split("\n", 1)
            found.extend(self._line(line))
        return found

    def finish(self) -> list[dict[str, Any]]:
        """The reply ended: read what is left, including an unterminated line."""
        found: list[dict[str, Any]] = []
        if self._buffer:
            line, self._buffer = self._buffer, ""
            found.extend(self._line(line))
        if self._pending:
            self.malformed += 1
            self._pending = []
        self._in_block = False
        return found

    def _line(self, line: str) -> list[dict[str, Any]]:
        if not self._in_block:
            if _fence_opens(line):
                self._in_block = True
                self.blocks += 1
            else:
                self.prose_lines.append(line)
            return []
        if _fence_closes(line):
            if self._pending:
                self.malformed += 1
                self._pending = []
            self._in_block = False
            return []
        if not line.strip() and not self._pending:
            return []
        self._pending.append(line)
        candidate = "\n".join(self._pending).strip()
        try:
            parsed = json.loads(candidate)
        except json.JSONDecodeError:
            if len(self._pending) >= _MAX_PENDING_LINES or not candidate.startswith("{"):
                self.malformed += 1
                self._pending = []
            return []
        self._pending = []
        if not isinstance(parsed, dict):
            self.malformed += 1
            return []
        return [parsed]

    async def _record_results(
        self,
        turn: dict[str, Any],
        moment: dict[str, Any],
        objects: list[dict[str, Any]],
        recorded: dict[tuple[str, str], dict[str, Any]],
    ) -> int:
        """Record each new result once per turn. The same result written again
        (a retried stream) is skipped; a changed one is kept as a revision."""
        count = 0
        target = moment.get("target_language") or "ko"
        for obj in objects:
            fields = normalize(obj)
            if fields is None:
                continue
            key = result_key(fields)
            earlier = recorded.get(key)
            if earlier is not None:
                if content_of(earlier) == content_of(fields):
                    continue
                fields["revises"] = earlier["id"]
            if turn.get("target_result"):
                fields.setdefault("about", turn["target_result"])
            record = await self._write(
                self.corpus.add_result,
                moment["id"],
                turn_id=turn["id"],
                target_language=target,
                fields=fields,
            )
            recorded[key] = record
            count += 1
            if record["kind"] == "card" and self.voice is not None:
                # The card is readable now; its voice follows (card first),
                # and the turn finishes only once the voice is recorded.
                voice = asyncio.ensure_future(self._speak_card(moment, record))
                self._turn_work.setdefault(turn["id"], []).append(voice)
        return count