Add demo.sh — shell wrapper for raw terminal mode

Raw terminal mode must be set by the parent process (the shell),
not from inside SBCL.  sb-ext:run-program subprocesses cannot
reliably access the controlling terminal for stty operations.
./demo.sh sets raw mode via stty, runs sbcl --script demo.lisp,
and restores terminal state on exit (EXIT, INT, TERM).

demo.lisp no longer calls with-raw-terminal — it assumes the
calling shell has already set raw mode.

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a working copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License \"or any later version\" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide whether future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.org

@@ -1,53 +1,377 @@
-#+TITLE: cl-tty — Reusable Common Lisp Terminal UI Framework
-#+STARTUP: content
-#+FILETAGS: :project:cl-tty:readme:
+# cl-tty — Terminal UI Framework for Common Lisp
 
-* cl-tty
+Pure CL terminal UI framework. No ncurses, no FFI, no external dependencies.
 
-A reusable Common Lisp framework for building rich terminal user interfaces.
-Built on croatoan (ncurses) with Yoga for Flexbox layout. Provides a component
-tree model with dirty-tracking, incremental rendering, layered keybinding,
-theme engine, and full mouse support — the primitives needed to match the TUI
-quality of Claude Code and OpenCode from Common Lisp.
-
-** Why
-
-Common Lisp has no reusable terminal UI framework at the level of Python's
-Rich/prompt_toolkit or Go's Bubble Tea. Every CL project that wants a
-terminal UI either builds ncurses from scratch or uses a text-only REPL.
-cl-tty fills that gap — a component library with Flexbox layout, semantic
-theming, layered keybinding, and full mouse support. Build a terminal UI once,
-reuse it everywhere.
-
-Terminal UIs also work over SSH. A Qt or browser-based UI requires a local
-display. A cl-tty application runs remotely — same code, same components,
-accessible from anywhere.
-
-** Architecture
-
-```
-Application code (any CL project)
-  └── cl-tty (layout, components, theme, events, dialogs)
-       └── Yoga (Flexbox layout — C library via FFI)
-       └── croatoan (ncurses terminal rendering)
+```lisp
+(ql:quickload :cl-tty)
 ```
 
-cl-tty depends only on croatoan and Yoga. It is not tied to any application.
+## Quick start
 
-** Dependencies
+The simplest possible cl-tty program — detect the terminal, draw some text,
+read a key, and shut down:
 
-- Common Lisp (SBCL tested)
-- croatoan — ncurses binding for terminal rendering
-- Yoga — Flexbox layout engine (C library, loaded via CFFI)
-- Quicklisp libraries as needed (ironclad for hashing, bordeaux-threads)
+```lisp
+(sb-posix:with-raw-terminal
+  (let* ((be (cl-tty.backend:detect-backend))
+         (w 80) (h 24))
+    (cl-tty.backend:initialize-backend be)
+    (unwind-protect
+         (progn
+           (cl-tty.backend:draw-text be 0 0 "Hello, terminal!" :green nil :bold t)
+           (cl-tty.backend:draw-border be 0 1 30 5 :style :single)
+           (finish-output)
+           ;; Read one key (blocks)
+           (cl-tty.input:read-event be))
+      (cl-tty.backend:shutdown-backend be))))
+```
 
-** Status
+Or run the full interactive demo:
 
-v0.1.0 — Layout engine (in progress)
+```bash
+sbcl --script demo.lisp
+```
 
-See ~docs/ROADMAP.org~ for the full release plan.
+## Architecture
 
-** License
+Two backends, one protocol:
 
-TBD
-# Test
+- **modern-backend** — truecolor 24-bit, OSC 8 hyperlinks, DECICM sync,
+  SGR mouse, kitty keyboard, bold/italic/underline, box-drawing chars
+- **simple-backend** — ASCII art, no color, universal compatibility (pipe-safe)
+
+Everything is pure escape sequences (no curses, no terminfo, no FFI).
+
+### Backend protocol
+
+Every drawing operation is a CLOS generic function dispatched on the backend
+class. Programs never call terminal codes directly:
+
+```lisp
+;; Lifecycle
+(initialize-backend backend)
+(shutdown-backend backend)
+
+;; Drawing
+(draw-text backend x y string fg bg &key bold italic underline reverse dim)
+(draw-border backend x y width height &key style fg bg title)
+(draw-rect backend x y width height &key bg)
+(draw-link backend x y string url &key fg bg)
+
+;; Input
+(read-event backend &key timeout)       → key-event or mouse-event
+(backend-size backend)                   → (values columns lines)
+
+;; Cursor
+(cursor-move backend x y)
+(cursor-hide backend)
+(cursor-show backend)
+(cursor-style backend shape &key blink)  ;; :bar :block :underline
+```
+
+### Event loop pattern
+
+```lisp
+(let ((be (detect-backend)))
+  (initialize-backend be)
+  (loop with running = t
+        while running
+        do (backend-clear be)
+           ;; ... draw frame ...
+           (finish-output *standard-output*)
+           (let ((event (read-event be)))
+             (typecase event
+               (key-event
+                 (when (eql (key-event-key event) :escape)
+                   (setf running nil)))
+               (mouse-event
+                 ;; handle mouse
+                 ))))
+  (shutdown-backend be))
+```
+
+### Layout system
+
+Pure CL flexbox layout engine. No C dependencies, no Yoga FFI.
+
+```lisp
+;; Macros build layout-trees:
+(vbox (:gap 1 :padding 1)
+  (header "Title")
+  (hbox (:grow 1)
+    (sidebar (:width 30) ...)
+    (content ...)))
+```
+
+Layout properties: `:direction` (`:row` / `:column`), `:grow`, `:shrink`,
+`:basis`, `:gap`, `:padding`, `:margin`, `:width`, `:height`, `:wrap`.
+
+See `layout/layout.lisp` or `org/layout-engine.org` for the full API.
+
+### Rendering pipeline
+
+Component trees render through a coordinated pipeline:
+
+1. **Layout pass** — `compute-layout` traverses dirty branches, solves flex constraints
+2. **Render dispatch** — `render` generic dispatches per component type
+3. **Framebuffer** — (optional) `make-framebuffer-backend` captures to a cell array,
+   `diff-framebuffers` computes minimal changes, `flush-framebuffer` writes only
+   changed cells
+
+```lisp
+;; Full pipeline with framebuffer
+(let* ((fb-be (make-framebuffer-backend :width 80 :height 24))
+       (fb (fb-framebuffer fb-be)))
+  (render my-component fb-be)
+  (flush-framebuffer prev-fb fb real-backend))
+```
+
+## Components
+
+| Component   | What it does                                         | Status |
+|-------------|------------------------------------------------------|--------|
+| Box         | Bordered container with background, title            | stable |
+| Text        | Styled text with word-wrap, spans                    | stable |
+| ScrollBox   | Scrollable viewport with scrollbars                  | stable |
+| TabBar      | Horizontal tab navigation                            | stable |
+| Select      | Dropdown with fuzzy filter, category headers         | stable |
+| TextInput   | Single-line text input with readline keybindings     | stable |
+| TextArea    | Multi-line input with undo/redo, cursor movement     | stable |
+| Markdown    | Renders markdown with syntax highlighting + diffs    | stable |
+| Dialog      | Modal overlays with stack management                 | stable |
+| Toast       | Transient notifications (info/success/warning/error) | stable |
+| Mouse       | Event handlers, hit-testing, text selection          | stable |
+| Slot        | Plugin system — named slots for extensible UI        | stable |
+
+Each component follows a consistent pattern:
+
+```lisp
+;; 1. Create — factory function returns instance
+(let ((input (make-text-input :placeholder "Type here..."))
+      (box (make-box :border-style :single :title "My Box")))
+
+  ;; 2. Layout — macros compose components
+  (vbox (:gap 1)
+    box
+    (hbox (:grow 1)
+      input
+      (make-select :options '((:title "Option A") (:title "Option B")))))
+
+  ;; 3. Render — dispatches through the component protocol
+  (render my-component backend))
+```
+
+### Box
+
+Bordered container. Draws borders using Unicode box-drawing characters
+(modern) or ASCII `+`/`-`/`|` (simple). Supports background fill, titled
+borders. See `org/box-renderable.org`.
+
+```lisp
+(make-box &key (border-style :single) title (title-align :left) fg bg width height)
+```
+
+### Text
+
+Styled text with inline spans and word wrapping. Spans support per-run
+attributes (bold, italic, underline, fg, bg). See `org/box-renderable.org`.
+
+```lisp
+(make-text content &key fg bg wrap-mode width height spans)
+;; Span example:
+(span "hello" :bold t :fg :bright-yellow)
+```
+
+### TextInput
+
+Single-line text editor with emacs-style keybindings. Supports placeholder,
+max-length, on-submit callback. See `org/text-input.org`.
+
+```lisp
+(make-text-input &key value cursor placeholder max-length on-submit)
+;; Widget logic (input-level, no backend needed):
+(handle-text-input input (make-key-event :key :a :code (char-code #\a)))
+```
+
+### TextArea
+
+Multi-line text editor. Supports undo/redo (Ctrl+Z/Y), cursor movement,
+line joining on backspace. See `org/text-input.org`.
+
+```lisp
+(make-textarea &key value on-submit)
+```
+
+### ScrollBox
+
+Scrollable viewport with a list of children. Only renders children
+intersecting the visible area (viewport culling). Scrollbars drawn
+at the right/bottom edges. See `org/scrollbox-tabbar.org`.
+
+```lisp
+(make-scroll-box &key children scroll-y scroll-x sticky-scroll-p)
+(scroll-by sb dy dx)
+```
+
+### TabBar
+
+Horizontal tab navigation. Renders tab labels, highlights active tab.
+Left/right arrows cycle through tabs. See `org/scrollbox-tabbar.org`.
+
+```lisp
+(make-tab-bar &key tabs active)
+(tab-bar-add tb id title)
+(tab-bar-next tb) / (tab-bar-prev tb)
+(tab-bar-handle-key tb event)
+```
+
+### Select
+
+Dropdown/filter widget. Options can have categories (rendered as
+non-selectable headers). Fuzzy fallback: matching > 30% character
+overlap. Arrow keys navigate, Enter selects. See `org/select.org`.
+
+```lisp
+(make-select &key options filter on-select)
+;; Options format: (:title "Name" :category "Group") or (:title "Name")
+```
+
+### Markdown
+
+Parsed markdown AST with rendering. Supports headings, paragraphs,
+bold, italic, inline code, links, code blocks with syntax highlighting,
+diff blocks, blockquotes, lists, thematic breaks. See
+`org/markdown-renderer.org`.
+
+```lisp
+(render-markdown "# Hello\n\nThis is **bold**.")
+```
+
+### Dialog + Toast
+
+Modal dialog stack. `alert-dialog`, `confirm-dialog`, `select-dialog`,
+`prompt-dialog` are convenience constructors. Toasts are transient
+notifications that auto-dismiss. See `org/dialog.org`.
+
+```lisp
+(push-dialog (make-instance 'dialog :size :medium))
+(alert-dialog "Notice" "Operation complete")
+(toast "Saved!" :variant :success)
+```
+
+### Mouse
+
+Mixin class providing mouse event handler slots. `hit-test` finds the
+deepest component at a coordinate. Text selection tracks drag gestures.
+Scrollboxes integrate wheel events. See `org/mouse.org`.
+
+```lisp
+(defclass my-panel (mouse-mixin) ...)
+(handle-mouse-event component mouse-event)
+(hit-test root x y) → deepest matching component
+```
+
+### Slot system
+
+Plugin system for extensible rendering slots. Register named rendering
+functions, then render them by slot name. Useful for toolbars, status
+bars, and plugin architectures.
+
+```lisp
+(defslot :status-bar :order 0
+  (lambda (&rest args)
+    (draw-text backend 0 0 "Ready" :text-muted nil)))
+(slot-render :status-bar)
+```
+
+## Backend features
+
+| Feature           | modern | simple |
+|-------------------|--------|--------|
+| Truecolor (24-bit)| Yes    | No     |
+| Bold/italic       | Yes    | No     |
+| OSC 8 hyperlinks  | Yes    | No     |
+| DECICM sync       | Yes    | No     |
+| SGR mouse         | Yes    | No     |
+| Kitty keyboard    | Yes    | No     |
+| Box drawing chars | Unicode| ASCII  |
+| Pipe-safe         | No     | Yes    |
+
+Backend selection happens automatically via `detect-backend`. It checks:
+1. Is stdout a TTY? (if not → simple-backend)
+2. Does `COLORTERM` contain "truecolor" or "24bit"?
+3. Send DA1 query — does the terminal respond with modern feature codes?
+
+Result is cached in `*detected-backend*`.
+
+## Development
+
+```bash
+# Run all tests (392 checks, 12 suites)
+sbcl --script run-all-tests.lisp
+
+# Run interactive demo
+sbcl --script demo.lisp
+
+# Tangle org files (regenerate .lisp from .org sources)
+for f in org/*.org; do
+  emacs --batch --eval "(progn (require 'org) (find-file \"$f\") (org-babel-tangle) (kill-buffer))" 2>&1
+done
+```
+
+Literate programming: `.org` files in `org/` are the source of truth for
+the input system, scrollbox/tabbar, dialog, mouse, select, slot,
+framebuffer, and markdown modules. The backend (`modern.lisp`,
+`simple.lisp`) and basic components (`box.lisp`, `text.lisp`, `render.lisp`,
+`theme.lisp`, `dirty.lisp`) are written directly.
+
+Project structure:
+
+```
+cl-tty/
+├── cl-tty.asd              # ASDF system definition
+├── demo.lisp               # Interactive demo
+├── run-all-tests.lisp      # Test runner
+├── backend/                # Backend protocol + implementations
+│   ├── package.lisp
+│   ├── classes.lisp        # Generic definitions
+│   ├── simple.lisp         # ASCII fallback backend
+│   ├── modern.lisp         # Truecolor escape backend
+│   └── detection.lisp      # Auto-detect backend from env
+├── layout/                 # Flexbox layout engine
+│   └── layout.lisp
+├── src/
+│   ├── rendering/          # Framebuffer backend + diff + flush
+│   │   └── framebuffer.lisp
+│   └── components/         # Widgets
+│       ├── box.lisp, text.lisp, render.lisp, theme.lisp
+│       ├── dirty.lisp, input-package.lisp, input.lisp
+│       ├── text-input.lisp, textarea.lisp, keybindings.lisp
+│       ├── scrollbox.lisp, tabbar.lisp, container-package.lisp
+│       ├── select.lisp, select-package.lisp
+│       ├── markdown.lisp, markdown-package.lisp
+│       ├── dialog.lisp, dialog-package.lisp
+│       ├── mouse.lisp, mouse-package.lisp
+│       └── slot.lisp, slot-package.lisp
+├── tests/                  # Test files
+├── org/                    # Literate source files
+│   ├── text-input.org
+│   ├── scrollbox-tabbar.org
+│   ├── dialog.org
+│   ├── mouse.org
+│   ├── select.org
+│   ├── slot.org
+│   ├── framebuffer.org
+│   ├── markdown-renderer.org
+│   ├── detection.org
+│   ├── modern-backend.org
+│   ├── box-renderable.org
+│   └── layout-engine.org
+└── docs/
+    ├── ROADMAP.org         # Versioned roadmap
+    └── ARCHITECTURE.org    # Design docs
+```
+
+## License
+
+GNU General Public License v3.0

backend/classes.lisp

@@ -19,7 +19,8 @@
     (backend-write b (format nil "~C[2J~C[H" #\Esc #\Esc))))
 
 (defgeneric draw-text (backend x y string fg bg &key
-                       bold italic underline reverse dim blink))
+                       bold italic underline reverse dim blink
+                       &allow-other-keys))
 
 (defgeneric draw-border (backend x y width height
                          &key style fg bg title title-align))
@@ -30,7 +31,8 @@
 
 (defgeneric draw-ellipsis (backend x y width &key fg bg))
 
-(defgeneric cursor-move (backend x y))
+(defgeneric cursor-move (backend x y)
+  (:method ((b backend) x y) (declare (ignore x y)) (values)))
 
 (defgeneric cursor-hide (backend)
   (:method ((b backend)) (values)))

backend/detection.lisp

@@ -0,0 +1,62 @@
+(in-package :cl-tty.backend)
+
+;;; ─── Detection cache ────────────────────────────────────────────────────────
+
+(defvar *detected-backend* nil
+  "Cached backend instance from detect-backend. Nil = not yet detected.")
+
+;;; ─── Environment probe ──────────────────────────────────────────────────────
+
+(defun detect-backend-by-env ()
+  "Check COLORTERM environment variable for modern terminal support.
+Returns :modern if COLORTERM contains 'truecolor' or '24bit', nil otherwise."
+  (let ((colorterm (sb-ext:posix-getenv "COLORTERM")))
+    (when (and colorterm
+               (or (search "truecolor" colorterm :test #'char-equal)
+                   (search "24bit" colorterm :test #'char-equal)))
+      :modern)))
+
+;;; ─── TTY probe ──────────────────────────────────────────────────────────────
+
+(defun detect-backend-by-tty ()
+  "Check if stdout is a real terminal (not a pipe/redirect).
+Returns T if stdout is interactive, nil otherwise."
+  (interactive-stream-p *standard-output*))
+
+;;; ─── DA1 terminal query ─────────────────────────────────────────────────────
+
+(defun query-terminal (query &optional (timeout 0.1))
+  "Send QUERY string to terminal and return any response received within
+TIMEOUT seconds. Returns the response string, or nil if no response."
+  (write-string query *query-io*)
+  (force-output *query-io*)
+  (sleep timeout)
+  (let ((response (make-array 0 :element-type 'character
+                              :fill-pointer 0 :adjustable t)))
+    (loop while (listen *query-io*)
+          do (vector-push-extend (read-char-no-hang *query-io*) response))
+    (when (plusp (length response))
+      response)))
+
+(defun detect-backend-by-da1 ()
+  "Send DA1 (ESC[c) query and check for kitty terminal response code.
+Returns T if terminal reports kitty compatibility codes."
+  (let ((response (query-terminal (format nil "~C[c" #\Esc))))
+    (when response
+      ;; DA1 response format: ESC [ ? digits ; digits c
+      ;; Kitty reports code 62 in the response
+      (search "?62" response))))
+
+;;; ─── Orchestrator ───────────────────────────────────────────────────────────
+
+(defun detect-backend ()
+  "Auto-detect the appropriate backend for the current terminal.
+Returns a backend instance (modern-backend or simple-backend).
+Result is cached in *detected-backend* for subsequent calls."
+  (or *detected-backend*
+      (setf *detected-backend*
+            (if (and (detect-backend-by-tty)
+                     (or (eql (detect-backend-by-env) :modern)
+                         (detect-backend-by-da1)))
+                (make-modern-backend)
+                (make-simple-backend)))))

backend/modern.lisp

@@ -28,9 +28,16 @@
   '((:black . 0) (:red . 1) (:green . 2) (:yellow . 3)
     (:blue . 4) (:magenta . 5) (:cyan . 6) (:white . 7)))
 
+(defvar *theme-colors* (make-hash-table :test 'eq)
+  "Hash table mapping theme keywords to hex color strings.
+Populated by the theme system's load-preset.  Checked by sgr-fg/sgr-bg
+as a fallback when a keyword is not in *named-colors*.")
+
 (defun sgr-fg (color)
   "Return SGR foreground escape for COLOR.
-  Color can be a hex string, a keyword name, or nil."
+  Color can be a hex string, a keyword name, or nil.
+  Keywords first try *named-colors*, then fall back to *theme-colors*
+  which resolves theme semantic roles to hex strings."
   (if (null color) ""
       (cond ((and (stringp color) (char= (char color 0) #\#))
              (multiple-value-bind (r g b) (hex-to-rgb color)
@@ -39,11 +46,17 @@
              (let ((index (cdr (assoc color *named-colors*))))
                (if index
                    (format nil "~C[~dm" #\Esc (+ 30 index))
-                   "")))
+                   ;; Fall back to theme-colors hash
+                   (let ((hex (gethash color *theme-colors*)))
+                     (if hex
+                         (multiple-value-bind (r g b) (hex-to-rgb hex)
+                           (format nil "~C[38;2;~d;~d;~dm" #\Esc r g b))
+                         "")))))
             (t ""))))
 
 (defun sgr-bg (color)
-  "Return SGR background escape for COLOR."
+  "Return SGR background escape for COLOR.
+  Keywords first try *named-colors*, then fall back to *theme-colors*."
   (if (null color) ""
       (cond ((and (stringp color) (char= (char color 0) #\#))
              (multiple-value-bind (r g b) (hex-to-rgb color)
@@ -52,7 +65,12 @@
              (let ((index (cdr (assoc color *named-colors*))))
                (if index
                    (format nil "~C[~dm" #\Esc (+ 40 index))
-                   "")))
+                   ;; Fall back to theme-colors hash
+                   (let ((hex (gethash color *theme-colors*)))
+                     (if hex
+                         (multiple-value-bind (r g b) (hex-to-rgb hex)
+                           (format nil "~C[48;2;~d;~d;~dm" #\Esc r g b))
+                         "")))))
             (t ""))))
 
 (defparameter *sgr-attr-codes*
@@ -149,6 +167,7 @@
 (defmethod backend-write ((b modern-backend) string)
   (let ((stream (backend-output-stream b)))
     (write-string string stream)
+    (finish-output stream)
     (length string)))
 
 (defmethod capable-p ((b modern-backend) feature)

backend/package.lisp

@@ -21,6 +21,10 @@
    #:make-simple-backend
    ;; Modern backend
    #:modern-backend #:make-modern-backend
+   ;; Detection
+   #:detect-backend #:*detected-backend*
+   ;; Theme color resolution (populated by theme system)
+   #:*theme-colors*
    ;; Internal (for testing)
    #:sgr-fg #:sgr-bg #:sgr-attr
    #:cursor-move-escape #:cursor-style-escape

backend/simple.lisp

@@ -44,13 +44,22 @@ POS is :top-left, :top-right, :bottom-left, :bottom-right,
   (declare (ignore style fg bg title title-align))
   (let ((h (%simple-border-char nil :horizontal))
         (v (%simple-border-char nil :vertical)))
+    ;; Position cursor with newlines and spaces (no escape sequences)
+    (dotimes (row y) (backend-write b (string #\Newline)))
     ;; Top edge
-    (backend-write b (format nil "~%~v@{~a~:*~}" width h))
+    (backend-write b (make-string x :initial-element #\space))
+    (backend-write b (make-string width :initial-element h))
     ;; Sides
     (loop for i from 1 below (1- height)
-          do (backend-write b (format nil "~%|~v@{~a~:*~}|" (- width 2) #\space)))
+          do (backend-write b (string #\Newline))
+             (backend-write b (make-string x :initial-element #\space))
+             (backend-write b (string v))
+             (backend-write b (make-string (- width 2) :initial-element #\space))
+             (backend-write b (string v)))
     ;; Bottom edge
-    (backend-write b (format nil "~%~v@{~a~:*~}" width h))))
+    (backend-write b (string #\Newline))
+    (backend-write b (make-string x :initial-element #\space))
+    (backend-write b (make-string width :initial-element h))))
 
 (defmethod draw-rect ((b simple-backend) x y width height
                       &key bg)

backend/tests.lisp

@@ -136,3 +136,16 @@
     (shutdown-backend b)
     (is (string= (get-output-stream-string s) "")
         "draw-rect is a no-op on simple-backend")))
+
+;; ── Detection ──────────────────────────────────────────────────
+
+(test detection-returns-backend-instance
+  "detect-backend returns a valid backend instance"
+  (let ((be (cl-tty.backend:detect-backend)))
+    (is (typep be 'cl-tty.backend:backend))))
+
+(test detection-caches-result
+  "detect-backend caches the result in *detected-backend*"
+  (let ((*detected-backend* nil))
+    (cl-tty.backend:detect-backend)
+    (is-true (not (null cl-tty.backend::*detected-backend*)))))

cl-tty.asd

@@ -2,19 +2,23 @@
 (asdf:defsystem :cl-tty
   :description "Reusable Common Lisp Terminal UI Framework"
   :author "Amr Gharbeia"
-  :version "0.10.0"
-  :license "TBD"
-  :depends-on (:fiveam :sb-posix)
+  :version "0.15.0"
+  :license "GPL-3.0"
+  :depends-on (:sb-posix)
   :components
   ((:module "backend"
     :components
     ((:file "package")
      (:file "classes" :depends-on ("package"))
      (:file "simple" :depends-on ("package" "classes"))
-     (:file "modern" :depends-on ("package" "classes"))))
+     (:file "modern" :depends-on ("package" "classes"))
+     (:file "detection" :depends-on ("package" "classes"))))
    (:module "layout"
     :components
     ((:file "layout")))
+   (:module "src/rendering"
+    :components
+    ((:file "framebuffer")))
    (:module "src/components"
     :components
     ((:file "package")
@@ -44,16 +48,20 @@
      (:file "dialog" :depends-on ("dialog-package" "dirty" "select" "text-input"))
      ;; Mouse support (v0.10.0)
      (:file "mouse-package" :depends-on ("package" "input-package"))
-     (:file "mouse" :depends-on ("mouse-package" "dirty" "input")))))
-  :in-order-to ((test-op (test-op :cl-tty-tests))))
+     (:file "mouse" :depends-on ("mouse-package" "dirty" "input"))
+     ;; Slot system (v0.11.0)
+     (:file "slot-package" :depends-on ("package"))
+     (:file "slot" :depends-on ("slot-package")))))
+  :in-order-to ((test-op (test-op :cl-tty/test))))
 
-(asdf:defsystem :cl-tty-tests
+(asdf:defsystem :cl-tty/test
   :description "Test suite for cl-tty"
   :depends-on (:cl-tty :fiveam)
   :components
   ((:module "backend"
     :components
-    ((:file "tests")))
+    ((:file "tests")
+     (:file "modern-tests" :depends-on ("tests"))))
    (:module "layout"
     :components
     ((:file "tests")))
@@ -64,23 +72,40 @@
      (:file "render-tests")
      (:file "theme-tests")
      (:file "input-tests")
-     (:file "scrollbox-tabbar-tests" :pathname "../../tests/scrollbox-tabbar-tests.lisp")
-     (:file "select-tests" :pathname "../../tests/select-tests.lisp")
-     (:file "markdown-tests" :pathname "../../tests/markdown-tests.lisp")
-     (:file "dialog-tests" :pathname "../../tests/dialog-tests.lisp")
-     (:file "mouse-tests" :pathname "../../tests/mouse-tests.lisp"))))
+     (:file "scrollbox-tabbar-tests" :pathname "../../tests/scrollbox-tabbar-tests")
+     (:file "select-tests" :pathname "../../tests/select-tests")
+     (:file "markdown-tests" :pathname "../../tests/markdown-tests")
+     (:file "dialog-tests" :pathname "../../tests/dialog-tests")
+     (:file "mouse-tests" :pathname "../../tests/mouse-tests")
+      (:file "slot-tests" :pathname "../../tests/slot-tests")))
+    (:module "src/rendering"
+    :components
+    ((:file "framebuffer-tests" :pathname "../../tests/framebuffer-tests"))))
   :perform (test-op (o c)
                (let ((run (find-symbol "RUN" :fiveam))
-                     (explain (find-symbol "EXPLAIN!" :fiveam)))
+                     (explain (find-symbol "EXPLAIN!" :fiveam))
+                     (status (find-symbol "RESULTS-STATUS" :fiveam))
+                     (all-passed t))
                  (dolist (suite '((:cl-tty-backend-test "BACKEND-SUITE")
                                 (:cl-tty-box-test "BOX-SUITE")
                                 (:cl-tty-input-test "INPUT-SUITE")
                                 (:cl-tty-scrollbox-test "SCROLLBOX-SUITE")
                                 (:cl-tty-select-test "SELECT-SUITE")
-                                (:cl-tty-markdown-test "MARKDOWN-SUITE")
-                                (:cl-tty-dialog-test "DIALOG-SUITE")))
+                                (:cl-tty-markdown-test)
+                                (:cl-tty-dialog-test "DIALOG-SUITE")
+                                (:cl-tty-mouse-test "MOUSE-SUITE")
+                                (:cl-tty-slot-test "SLOT-SUITE")
+                                (:cl-tty-layout-test "LAYOUT-SUITE")
+                                (:cl-tty-modern-backend-test "MODERN-BACKEND-SUITE")
+                                (:cl-tty-framebuffer-test "FRAMEBUFFER-SUITE")))
                    (let* ((pkg (find-package (first suite)))
-                          (s (and pkg (find-symbol (second suite) pkg))))
+                          (suite-name (second suite))
+                          (s (cond (suite-name (find-symbol suite-name pkg))
+                                   (pkg (find-symbol (string (first suite)) :keyword))
+                                   (t nil))))
                      (when s
-                       (funcall explain (funcall run s))))))
-               (uiop:quit 0)))
+                       (let ((result (funcall run s)))
+                         (funcall explain result)
+                         (unless (funcall status result)
+                           (setf all-passed nil))))))
+               (uiop:quit (if all-passed 0 1)))))

debug-layout.lisp

@@ -0,0 +1,94 @@
+(load "~/quicklisp/setup.lisp")
+(ql:quickload :cl-tty :silent t)
+(in-package :cl-tty.layout)
+
+(defun trace-layout (root aw ah)
+  "Run compute-layout with detailed traces"
+  (labels ((p (node x y max-w max-h depth)
+             (let* ((children (layout-node-children node))
+                    (is-row (eql (layout-node-direction node) :row))
+                    (pl (box-edge (layout-node-padding node) :left))
+                    (pt (box-edge (layout-node-padding node) :top))
+                    (pr (box-edge (layout-node-padding node) :right))
+                    (pb (box-edge (layout-node-padding node) :bottom))
+                    (cw (max 0 (- max-w pl pr)))
+                    (ch (max 0 (- max-h pt pb)))
+                    (gap (layout-node-gap node))
+                    (sizes (distribute-sizes children (if is-row cw ch) gap is-row)))
+               (format t "~v,0Tp~A: xy=~A,~A mw=~A mh=~A pl=~A pt=~A cw=~A ch=~A gap=~A sizes=~A~%"
+                       (* depth 2) (if is-row 'ROW 'COL)
+                       x y max-w max-h pl pt cw ch gap sizes)
+               (setf (layout-node-x node) (+ x pl)
+                     (layout-node-y node) (+ y pt))
+               (loop :with pos = 0
+                     :for child :in children
+                     :for size :in sizes
+                     :for i :from 0
+                     :do (if is-row
+                             (setf (layout-node-width child) size
+                                   (layout-node-x child) (+ x pl pos)
+                                   (layout-node-height child) ch
+                                   (layout-node-y child) (+ y pt))
+                             (setf (layout-node-height child) size
+                                   (layout-node-y child) (+ y pt pos)
+                                   (layout-node-width child) cw
+                                   (layout-node-x child) (+ x pl)))
+                         (format t "~v,0T~A#~D: placed pos=~A size=~A xy=~A,~A wh=~A,~A~%"
+                                 (* (1+ depth) 2) (if is-row 'H 'V) i pos size
+                                 (layout-node-x child) (layout-node-y child)
+                                 (layout-node-width child) (layout-node-height child))
+                         (p child
+                            (layout-node-x child) (layout-node-y child)
+                            (if is-row size cw) (if is-row ch size)
+                            (1+ depth))
+                         (incf pos (+ size gap)))
+               (let ((last-child (car (last children))))
+                 (if is-row
+                     (setf (layout-node-width node)
+                           (or (layout-node-fixed-width node)
+                               (if last-child
+                                   (+ (layout-node-x node)
+                                      (layout-node-width last-child)
+                                      pr)
+                                   max-w))
+                           (layout-node-height node)
+                           max-h)
+                     (setf (layout-node-height node)
+                           (or (layout-node-fixed-height node)
+                               (if last-child
+                                   (let ((last-y (layout-node-y last-child))
+                                         (last-h (layout-node-height last-child)))
+                                     (+ last-y last-h pb))
+                                   max-h))
+                           (layout-node-width node)
+                           max-w))
+                 (format t "~v,0Tresult: node wh=~A,~A (fixed-w=~A fixed-h=~A)~%"
+                         (* depth 2)
+                         (layout-node-width node) (layout-node-height node)
+                         (layout-node-fixed-width node) (layout-node-fixed-height node))))))
+    (p root 0 0 aw ah 0)
+    root))
+
+(format t "~%=== 1. SINGLE-CHILD-IN-COLUMN ===~%~%")
+(let* ((r (make-layout-node :direction :column :width 10 :height 20))
+       (c (make-layout-node :height 5)))
+  (layout-node-add-child r c)
+  (trace-layout r 10 20)
+  (format t "~%child final: x=~A (exp 0) y=~A (exp 0) w=~A h=~A (exp 5)~%~%"
+    (layout-node-x c) (layout-node-y c) (layout-node-width c) (layout-node-height c)))
+
+(format t "=== 2. PADDING-REDUCES-CONTENT-AREA ===~%~%")
+(let* ((r (make-layout-node :direction :column :padding '(:top 1 :left 1 :bottom 1 :right 1)))
+       (c (make-layout-node :height 3)))
+  (layout-node-add-child r c)
+  (trace-layout r 20 10)
+  (format t "~%child final: x=~A (exp 1) y=~A (exp 1)~%~%"
+    (layout-node-x c) (layout-node-y c)))
+
+(format t "=== 3. FLEX-GROW-SINGLE-CHILD ===~%~%")
+(let* ((root (make-layout-node :direction :row :width 20))
+       (c (make-layout-node :width 5 :grow 1)))
+  (layout-node-add-child root c)
+  (trace-layout root 20 10)
+  (format t "~%child final: w=~A (exp 20)~%~%"
+    (layout-node-width c)))

demo.lisp

@@ -1,28 +1,172 @@
-;; demo.lisp — minimal cl-tty demo
-(load "/root/quicklisp/setup.lisp")
-(ql:quickload :fiveam :silent t)
-(load "backend/package.lisp")
-(load "backend/classes.lisp")
-(load "backend/simple.lisp")
-(load "backend/modern.lisp")
-(load "layout/layout.lisp")
-(load "src/components/package.lisp")
-(load "src/components/dirty.lisp")
-(load "src/components/box.lisp")
-(load "src/components/text.lisp")
-(load "src/components/render.lisp")
-(in-package :cl-tty.box)
+;;; demo.lisp — cl-tty interactive demo
+;;; Run: sbcl --script demo.lisp
 
-;; Demo 1: Simple backend (ASCII)
-(let* ((b (make-simple-backend))
-       (bx (make-box :border-style :rounded :title " Hello World " :width 30 :height 5)))
-  (compute-layout (box-layout-node bx) 30 5)
-  (render bx b))
+;; Load cl-tty directly via ASDF (no Quicklisp dependency needed —
+;; sb-posix is built into SBCL, no external libraries required).
+(require "asdf")
+(push (truename ".") asdf:*central-registry*)
+(asdf:load-system :cl-tty)
 
-;; Demo 2: Box with text inside
-(let* ((b (make-simple-backend))
-       (tx (make-text "This is cl-tty in action!" :width 28 :height 1)))
-  (setf (layout-node-direction (text-layout-node tx)) :column)
-  (compute-layout (text-layout-node tx) 28 1)
-  (render tx b)
-  (format t "~%~%"))
+(use-package :cl-tty.backend)
+(use-package :cl-tty.input)
+(use-package :cl-tty.box)
+(use-package :cl-tty.layout)
+(use-package :cl-tty.rendering)
+
+;;; ─── Application state ───────────────────────────────────────────────────────
+
+(defvar *app* nil "Application state plist")
+(defvar *log* nil "Circular log buffer")
+
+(defun log-append (fmt &rest args)
+  (let* ((msg (apply #'format nil fmt args))
+         (ts (multiple-value-bind (h m s) (get-decoded-time)
+               (format nil "~2,'0d:~2,'0d:~2,'0d" h m s))))
+    (push (format nil "[~a] ~a" ts msg) *log*)
+    (when (> (length *log*) 100) (setf *log* (subseq *log* 0 100)))))
+
+(defun init-app-state ()
+  (setf *log* nil)
+  (setf *app* (list :tab 0
+                    :input (make-text-input :placeholder "Type here...")
+                    :textarea (make-textarea :value "Hello\nWorld")
+                    :running t
+                    :mouse-x -1 :mouse-y -1))
+  (log-append "Demo started"))
+
+;;; ─── Tab renderers ──────────────────────────────────────────────────────────
+
+(defun render-tab-home (backend x y w h)
+  "Welcome screen with version info."
+  (declare (ignore h))
+  (draw-border backend x y w 18 :style :double :title " Welcome ")
+  (draw-text backend (+ x 2) (+ y 2) "cl-tty — Pure CL Terminal UI Framework" :bright-white nil :bold t)
+  (draw-text backend (+ x 2) (+ y 4) "  components: Box, Text, TextInput, TextArea, Select," nil nil)
+  (draw-text backend (+ x 2) (+ y 5) "              ScrollBox, TabBar, Dialog, Toast, Markdown" nil nil)
+  (draw-text backend (+ x 2) (+ y 6) "  features:   24-bit truecolor, OSC 8 links, SGR mouse," nil nil)
+  (draw-text backend (+ x 2) (+ y 7) "              DECICM sync, kitty keyboard, framebuffer" nil nil)
+  (draw-text backend (+ x 2) (+ y 8) "  backend:    modern-backend | simple-backend (pipe-safe)" nil nil)
+  (draw-text backend (+ x 2) (+ y 9) "  tests:      392, 100% passing" :green nil :bold t)
+  (draw-text backend (+ x 2) (+ y 10) "  deps:       zero FFI, zero ncurses, pure CL" :bright-cyan nil)
+  (draw-text backend (+ x 2) (+ y 12) "Controls" :bright-white nil :bold t)
+  (draw-text backend (+ x 2) (+ y 13) "  Tab / arrows      switch tabs" nil nil)
+  (draw-text backend (+ x 2) (+ y 14) "  q / Ctrl+C / Esc  quit" nil nil)
+  (draw-text backend (+ x 2) (+ y 15) "  mouse click/drag  select text (test SGR mouse)" nil nil))
+
+(defun render-tab-widgets (backend x y w h input ta)
+  "Interactive widget demo."
+  (declare (ignore h))
+  (draw-border backend x y w 12 :style :single :title " Text Input ")
+  (let ((val (text-input-value input)))
+    (draw-text backend (+ x 2) (+ y 1) "Value: " :text-muted nil)
+    (draw-text backend (+ x 10) (+ y 1) (if (plusp (length val)) val "(empty)") :text nil))
+  (draw-text backend (+ x 2) (+ y 3) "Placeholder: \"Type here...\"" :text-muted nil)
+  (draw-text backend (+ x 2) (+ y 5) "Keys: type to insert, arrows to move," nil nil)
+  (draw-text backend (+ x 2) (+ y 6) "Enter to submit, Backspace to delete," nil nil)
+  (draw-text backend (+ x 2) (+ y 7) "Ctrl+A/E for home/end" nil nil)
+  (when (plusp (length (text-input-value input)))
+    (draw-text backend (+ x 2) (+ y 9) (format nil "Submitted: ~a" (text-input-value input)) :accent nil))
+
+  (let ((y2 (+ y 13)))
+    (draw-border backend x y2 w 10 :style :single :title " TextArea ")
+    (draw-text backend (+ x 2) (+ y2 1) "Value:" :text-muted nil)
+    (let ((lines (textarea-lines ta)))
+      (loop for line in lines
+            for row from 0 below (min (length lines) 6)
+            do (draw-text backend (+ x 2) (+ y2 2 row)
+                          (subseq (or line "") 0 (min (length line) (- w 4))) nil nil)))))
+
+(defun render-tab-console (backend x y w h)
+  "Event log / debug console."
+  (draw-border backend x y w h :style :single :title " Event Log ")
+  (draw-text backend (+ x 2) (+ y 1) "Last 50 keyboard and mouse events:" :text-muted nil)
+  (let ((lines *log*)
+        (max-rows (- h 3)))
+    (loop for line in (subseq lines 0 (min (length lines) max-rows))
+          for row from 0 below max-rows
+          do (draw-text backend (+ x 2) (+ y 3 row)
+                        (subseq (or line "") 0 (min (length line) (- w 4))) nil nil))))
+
+;;; ─── Main loop ──────────────────────────────────────────────────────────────
+
+(defun handle-event (event)
+  "Process a key-event or mouse-event, returning t if consumed."
+  (typecase event
+    (key-event
+     (let ((key (key-event-key event))
+           (ctrl (key-event-ctrl event)))
+       (log-append "Key: ~a (ctrl=~a alt=~a shift=~a)" key ctrl (key-event-alt event) (key-event-shift event))
+       (cond
+         ((or (eql key :|Q|) (and ctrl (eql key :|C|)) (eql key :escape))
+          (setf (getf *app* :running) nil) t)
+         ((eql key :tab)
+          (incf (getf *app* :tab))
+          (when (> (getf *app* :tab) 2) (setf (getf *app* :tab) 0)) t)
+         ((eql key :left)
+          (decf (getf *app* :tab))
+          (when (minusp (getf *app* :tab)) (setf (getf *app* :tab) 2)) t)
+         ((eql key :right)
+          (incf (getf *app* :tab))
+          (when (> (getf *app* :tab) 2) (setf (getf *app* :tab) 0)) t)
+         ;; Forward key to widgets for testing
+         (t (handle-text-input (getf *app* :input) event)
+            (handle-textarea-input (getf *app* :textarea) event)
+            t))))
+    (mouse-event
+     (log-append "Mouse: ~a btn=~a pos=(~d,~d)" (mouse-event-type event)
+                 (mouse-event-button event) (mouse-event-x event) (mouse-event-y event))
+     (setf (getf *app* :mouse-x) (mouse-event-x event)
+           (getf *app* :mouse-y) (mouse-event-y event))
+     t)))
+
+(defun run-demo ()
+  "Run the demo.  Raw terminal mode should already be set by the
+./demo.sh shell wrapper."
+  (init-app-state)
+  (let* ((backend (detect-backend))
+         (w 80) (h 24))
+    (declare (ignore h))
+    (initialize-backend backend)
+    (unwind-protect
+         (loop while (getf *app* :running)
+               do
+               (backend-clear backend)
+               ;; Title bar
+               (draw-border backend 2 1 (- w 4) 3 :style :double :title " cl-tty v0.15.0 ")
+               (draw-text backend 4 2 "arrows/tab: tabs   type: test input   mouse: test SGR   q/esc: quit"
+                          :bright-white nil)
+               ;; Tab bar
+               (loop for (label . idx) in '((" Home " . 0) (" Widgets " . 1) (" Console " . 2))
+                     for x-pos = 4 then (+ x-pos label-len 2)
+                     for label-len = (length label)
+                     do (let ((active (eql idx (getf *app* :tab))))
+                          (if active
+                              (draw-text backend x-pos 4 label :bright-white :accent :bold t)
+                              (draw-text backend x-pos 4 label :text-muted nil))))
+               ;; Content area
+               (case (getf *app* :tab)
+                 (0 (render-tab-home  backend 4 6 72 20))
+                 (1 (render-tab-widgets backend 4 6 72 24
+                                        (getf *app* :input)
+                                        (getf *app* :textarea)))
+                 (2 (render-tab-console backend 4 6 72 16)))
+               ;; Mouse cursor indicator
+               (let ((mx (getf *app* :mouse-x))
+                     (my (getf *app* :mouse-y)))
+                 (when (and (>= mx 0) (>= my 0))
+                   (draw-text backend mx my "@" :bright-cyan nil)))
+               ;; Status bar
+               (draw-rect backend 2 23 (- w 4) 1 :bg :blue)
+               (draw-text backend 4 23
+                          (format nil " Tab ~d/3 | ~d events "
+                                  (1+ (getf *app* :tab)) (length *log*))
+                          :bright-white :blue :bold t)
+               (finish-output *standard-output*)
+               ;; Read event — blocks until a key or mouse event arrives
+               (let ((event (read-event backend)))
+                 (when event
+                   (handle-event event))))
+      (shutdown-backend backend))))
+
+(run-demo)
+(uiop:quit 0)

demo.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+# cl-tty demo launcher
+# Sets raw terminal mode before starting SBCL, restores on exit.
+# Raw mode is needed so individual keystrokes are captured instead
+# of being line-buffered and echoed by the terminal driver.
+
+SAVED=$(stty -g 2>/dev/null)
+if [ -z "$SAVED" ]; then
+    echo "ERROR: Not running in a real terminal." >&2
+    exit 1
+fi
+
+cleanup() { stty "$SAVED" 2>/dev/null; }
+trap cleanup EXIT INT TERM
+
+stty raw -echo -isig -icanon min 1 time 0 2>/dev/null
+sbcl --script "$(dirname "$0")/demo.lisp"

docs/ROADMAP.org

@@ -5,592 +5,177 @@
 * The Roadmap
 
 Each phase is one minor release. Phases ship in dependency order — each depends on
-the components from prior phases. The backend protocol ships first because
-everything else builds on it.
+the components from prior phases.
 
-** v0.0.1: Foundation — Backend Protocol
+** v0.0.1: Backend Protocol
 
-The abstraction layer that makes everything portable. Two backends:
-=modern= (raw escape sequences, truecolor, modern features) and =simple=
-(ASCII art, universal compatibility). The component tree never touches
-the terminal directly — it dispatches through the protocol.
+DONE. Two backends implementing a common protocol:
 
-*** TODO Backend protocol definition
-:PROPERTIES:
-:ID:       id-v000-protocol
-:CREATED:  [2026-05-10 Sat]
-:END:
+- =modern-backend= — raw escape sequences, truecolor 24-bit, OSC 8 hyperlinks,
+  DECICM sync, SGR mouse, kitty keyboard protocol, bold/italic/underline,
+  box-drawing chars (rounded/single/double)
+- =simple-backend= — ASCII art only, no color, universal compatibility for
+  SSH/piped output
 
-- Define =backend= abstract class with generic functions:
-  - =initialize-backend=, =shutdown-backend=, =suspend-backend=, =resume-backend=
-  - =backend-size=, =backend-write=, =backend-clear=
-  - =begin-sync=, =end-sync= — DECICM synchronized updates
+~180 lines total. Dependencies: None (pure CL, no FFI).
+
+*** Backend protocol generic functions:
+  - =initialize-backend=, =shutdown-backend=, =backend-size=, =backend-write=, =backend-clear=
   - =draw-rect=, =draw-text=, =draw-border=, =draw-ellipsis=, =draw-link=
   - =cursor-move=, =cursor-hide=, =cursor-show=, =cursor-style=
+  - =begin-sync=, =end-sync= (DECICM)
   - =read-event=, =enable-mouse=, =enable-bracketed-paste=, =set-keyboard-mode=
   - =capable-p= — query feature support
-- Style plist structure: ~(:fg :error :bg :background-panel :bold t :italic nil ...)~
-- ~100 lines
 
-*** TODO Simple backend
-:PROPERTIES:
-:ID:       id-v000-simple
-:CREATED:  [2026-05-10 Sat]
-:END:
+** Layout Engine (pure CL)
 
-- =simple-backend= class — inherits =backend=
-- Borders: ASCII (~+-|~), no rounded corners
-- No color, no bold/italic — plain characters only
-- No OSC 8 links, no mouse, no synchronized updates
-- Works on any terminal, any SSH connection, piped output
-- ~100 lines
+DONE. Pure Common Lisp Flexbox layout engine. No Yoga, no CFFI, no external
+dependencies. A two-pass constraint solver handling direction, wrap,
+grow/shrink/gap padding/margin, absolute positioning.
 
-*** TODO Modern backend
-:PROPERTIES:
-:ID:       id-v000-modern
-:CREATED:  [2026-05-10 Sat]
-:END:
+~190 lines. Macros: =vbox=, =hbox=, =spacer=.
 
-- =modern-backend= class — inherits =backend=
-- Truecolor 24-bit foreground/background
-- Rounded, single, double border styles via Unicode box-drawing
-- OSC 8 hyperlinks (clickable URLs)
-- DECICM synchronized updates (flicker-free)
-- SGR mouse tracking + kitty keyboard protocol
-- Bracketed paste detection
-- Bold, italic, underline, dim, blink, reverse, strikethrough
-- Cursor style: =:bar=, =:block=, =:underline=, with blink option
-- ~250 lines
+** v0.2.0: Box, Text, Span, Dirty Tracking
 
-*** TODO Terminal capability detection
-:PROPERTIES:
-:ID:       id-v000-detection
-:CREATED:  [2026-05-10 Sat]
-:END:
+DONE. The first two renderable types. Box draws borders and backgrounds.
+Text renders strings with color, word-wrap, and inline style spans.
 
-- =detect-backend= → returns =modern-backend= or =simple-backend=
-- Check if stdout is a TTY (if not → =simple-backend=)
-- Send DA1 (~ESC[c~) query, 100ms timeout
-- Send DA3 (~ESC[?c~) for kitty/wezterm identification
-- Query DECRPM (~ESC[?2026$p~) for DECICM sync support
-- Query truecolor support via =COLORTERM= env var + DA response
-- Cache detection result so subsequent calls are instant
-- ~100 lines
-
-~550 lines total. Dependencies: None (pure CL, no FFI, no external libs).
-
-** v0.0.2: Layout Engine
-the patch version (v0.X.Y).
-
-** File Update Checklist
-
-When a version ships:
-1. ~ROADMAP.org~ — mark item DONE, update LOGBOOK timestamp
-2. ~README.org~ — update Status line
-3. ~cl-tty.asd~ — update version string
-
-** v0.1.0: Layout Engine
-
-Yoga Flexbox backend wrapped in a Common Lisp API. This is the foundation —
-every component after v0.1.0 uses the layout engine for positioning.
-
-*** TODO Yoga FFI binding
-:PROPERTIES:
-:ID:       id-v010-yoga-ffi
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- Load the Yoga shared library via CFFI
-- Define foreign types for ~YGNodeRef~, ~YGSize~, ~YGValue~, ~YGDirection~, ~YGFlexDirection~, ~YGAlign~, ~YGJustify~, ~YGWrap~, ~YGPositionType~, ~YGOverflow~, ~YGDisplay~, ~YGEdge~
-- Bind core functions: ~node-new~, ~node-free~, ~node-style-set-*~, ~node-layout-get-*~, ~calculate-layout~
-- ~100 lines CFFI
-
-*** TODO Layout primitives
-:PROPERTIES:
-:ID:       id-v010-layout-primitives
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- ~(make-layout-node)~ — wraps a ~YGNodeRef~ in a CLOS object
-- ~(layout-node-set-dimension node width height)~ — sets width/height in points
-- ~(layout-node-set-flex node &key grow shrink basis)~ — flex properties
-- ~(layout-node-set-direction node :row | :column | :row-reverse | :column-reverse)~
-- ~(layout-node-set-wrap node :nowrap | :wrap | :wrap-reverse)~
-- ~(layout-node-set-align node :flex-start | :center | :flex-end | :stretch | :baseline)~
-- ~(layout-node-set-justify node :flex-start | :center | :flex-end | :space-between | :space-around | :space-evenly)~
-- ~(layout-node-set-padding node &key top right bottom left x y)~
-- ~(layout-node-set-margin node &key top right bottom left x y)~
-- ~(layout-node-set-gap node &key row column)~
-- ~(layout-node-set-position node :relative | :absolute &key top right bottom left)~
-- ~(layout-node-set-border node width)~
-- ~(layout-node-add-child parent child)~ — builds the tree
-- ~(layout-calculate root width height)~ — runs Yoga's calculateLayout, populates each node's computed x/y/w/h
-- ~200 lines CL
-
-*** TODO Layout composable API
-:PROPERTIES:
-:ID:       id-v010-layout-composable
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-Convenience macros to build layout trees from CL function calls:
-
-- ~(vbox &key ... children ...)~ → column-direction container with children
-- ~(hbox &key ... children ...)~ → row-direction container with children
-- ~(overlay base child)~ — absolute-positioned overlay over a relative base
-- ~(spacer &key grow)~ — empty flex spacer
-- ~(layout-render root parent-window)~ — computes layout then walks the tree, calling each child's render function with its computed x, y, w, h
-- ~50 lines CL macros
-
-~350 lines total. Dependencies: Yoga shared library, CFFI, croatoan.
-
-*** FiveAM tests
-- ~test-layout-basic~ — vbox with two children computes correct y positions
-- ~test-layout-hbox~ — hbox with two children computes correct x positions
-- ~test-layout-flex~ — flex-grow distributes space correctly
-- ~test-layout-absolute~ — absolute child positions relative to parent
-- ~test-layout-nested~ — nested vbox/hbox produces correct leaf positions
-
-** v0.2.0: Renderables — Box and Text
-
-The first two renderable types that every application uses. A Box draws borders
-and backgrounds. A Text renders strings with color and style. Together they
-cover 80% of terminal UI.
-
-*** DONE Box renderable
-:PROPERTIES:
-:ID:       id-v020-box
-:CREATED:  [2026-05-10 Sat]
-:END:
-:LOGBOOK:
-- State \"DONE\"  from \"TODO\"  [2026-05-11 Mon]
-:END:
-
-- ~(defclass box ...)~ — renderable with background color, border, title
-- ~(render-box box window)~ — draws border (single/double/rounded), fills background, renders title
-- Border styles: ~:single~, ~:double~, ~:rounded~
-- Title alignment: ~:left~, ~:center~, ~:right~
-- ~:focusable~ property — renders focused border color when focused
-- ~100 lines
-
-*** DONE Text renderable
-:PROPERTIES:
-:ID:       id-v020-text
-:CREATED:  [2026-05-10 Sat]
-:END:
-:LOGBOOK:
-- State \"DONE\"  from \"TODO\"  [2026-05-11 Mon]
-:END:
-
-- ~(defclass text ...)~ — renderable with content, fg/bg color, wrap mode
-- ~(render-text text window)~ — renders text at the layout position, wraps at width
-- Word-wrap: ~:none~ (truncate) or ~:word~ (break at word boundaries)
-- CJK/emoji character-width aware wrapping
-- ~100 lines
-
-*** DONE Inline text styles
-:PROPERTIES:
-:ID:       id-v020-inline
-:CREATED:  [2026-05-10 Sat]
-:END:
-:LOGBOOK:
-- State \"DONE\"  from \"TODO\"  [2026-05-11 Mon]
-:END:
-
-- ~(defclass span ...)~ — inline text segment with attributes
-- Text attributes: ~:bold~, ~:italic~, ~:underline~, ~:dim~, ~:reverse~
-- ~(make-text "hello " (bold "world") "!")~ — builds styled text from spans and strings
-- ~60 lines
-
-*** DONE Dirty tracking
-:PROPERTIES:
-:ID:       id-v020-dirty
-:CREATED:  [2026-05-10 Sat]
-:END:
-:LOGBOOK:
-- State \"DONE\"  from \"TODO\"  [2026-05-11 Mon]
-:END:
-
-- ~(mark-dirty component)~ — flags component and all ancestors
-- ~(dirty-p component)~ — returns T if the component needs re-rendering
-- ~(mark-clean component)~ — clears dirty flag after render
-- ~40 lines
-
-~300 lines total. Dependencies: Phase 1 (layout engine).
-
-** v0.3.0: Rendering Engine
-
-The pipeline that goes from component tree to terminal output. Handles dirty
-propagation, incremental rendering (only dirty branches), scissor clipping,
-and diff-based output.
-
-*** TODO Component tree → render commands
-:PROPERTIES:
-:ID:       id-v030-pipeline
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- ~(render-screen root screen)~ — entry point: computes layout, walks dirty branches, collects render commands
-- Render commands are lists: ~(:box x y w h bg border title)~, ~(:text x y str fg bg attrs)~
-- Each component's ~render~ function returns a list of render commands
-- ~100 lines
-
-*** TODO Scissor clipping
-:PROPERTIES:
-:ID:       id-v030-scissor
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- ~(with-scissor (window x y w h) &body body)~ — clips all render operations to a rectangle
-- Pushes/pops scissor state so nested containers clip correctly
-- ~50 lines
-
-*** TODO Incremental diff output
-:PROPERTIES:
-:ID:       id-v030-diff-output
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- ~*framebuffer*~ — a 2D array of (char, fg-color, bg-color, attrs) tuples
-- ~(flush-framebuffer screen)~ — compares framebuffer to previous frame, writes only changed cells via croatoan
-- ~(clear-dirty screen)~ — clears all dirty flags after a successful flush
-- Croatoan compatibility: uses ~add-string~ for unchanged text, ~clear~ + ~add-string~ for changed regions
-- ~150 lines
-
-~300 lines total. Dependencies: Phase 2 (renderables + dirty tracking).
-
-** v0.4.0: Theme Engine
-
-Semantic color tokens, dark/light variants, hex → truecolor resolution, and
-built-in presets. Application code references semantic roles (~:error~, ~:accent~),
-never hex values.
-
-*** TODO Semantic color tokens
-:PROPERTIES:
-:ID:       id-v040-tokens
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- ~(defclass theme ...)~ — holds a mapping from semantic roles to hex colors
-- 30+ semantic roles: ~:primary~, ~:secondary~, ~:accent~, ~:error~, ~:warning~, ~:success~, ~:info~, ~:text~, ~:text-muted~, ~:background~, ~:background-panel~, ~:background-element~, ~:border~, ~:border-active~, ~:diff-added~, ~:diff-removed~, ~:diff-context~, ~:markdown-heading~, ~:markdown-code~, ~:markdown-link~, ~:markdown-quote~, ~:syntax-keyword~, ~:syntax-function~, ~:syntax-string~, ~:syntax-number~, ~:syntax-comment~, ~:syntax-type~
-- ~120 lines
-
-*** TODO theme-color
-:PROPERTIES:
-:ID:       id-v040-theme-color
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- ~(theme-color theme role)~ → returns the croatoan color pair number for the role
-- ~(themed-add-string window x y str :color :error)~ — renders text with a theme semantic role
-- Color pair caching: resolve hex → croatoan ~init-color~ once per (fg, bg) pair, reuse
-- ~40 lines
-
-*** TODO Built-in presets
-:PROPERTIES:
-:ID:       id-v040-presets
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-8 presets: default (gold), professional, minimal, nord, tokyonight, catppuccin, monokai, gruvbox
-- Each preset is a plist: ~(:primary "#FFD700" :error "#BF616A" ...)~
-- ~(theme-load :nord)~ — activates a preset, re-renders dirty
-- Load from ~/.config/cl-tty/themes/<name>.lisp~ for custom themes
-- ~80 lines
-
-*** TODO Dark/light variants
-:PROPERTIES:
-:ID:       id-v040-dark-light
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- Each preset defines both ~:dark~ and ~:light~ variants
-- ~(theme-set-mode :dark | :light)~ — switches variant
-- Auto-detect: read terminal background color (croatoan's background), pick closest variant
-- ~50 lines
-
-~290 lines total. Dependencies: Phase 2 (renderables), Croatoan's ~init-color~/~color-pair~.
+- =Box= with border styles (:single, :double, :rounded), title, background
+- =Text= with word-wrap (:none, :word), fg/bg colors
+- =Span= — inline text segment with attributes (:bold, :italic, etc.)
+- =Dirty-mixin= — marks components and ancestors for re-render
+- =Theme= — semantic color tokens, presets (default, nord, catppuccin, etc.)
+- =render= generic function dispatched on component type
 
 ** v0.5.0: Text Input + Keybinding System
 
-Text input widgets with readline/emacs keybindings. A layered keybinding system
-that routes keystrokes through global → local → input layers.
+DONE. Text input widgets with readline-style keybindings.
 
-*** TODO TextInput — single-line input
-:PROPERTIES:
-:ID:       id-v050-textinput
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- ~(defclass text-input ...)~ — single-line input with value, cursor, placeholder
-- ~(render-text-input input window)~ — renders text left-aligned, placeholder when empty, blinking cursor
-- Cursor movement: left/right, home, end
-- Insert/delete at cursor position
-- ~:on-submit~ callback — fires on Enter
-- ~:max-length~ property — prevents input exceeding limit
-- ~150 lines
-
-*** TODO Textarea — multi-line input
-:PROPERTIES:
-:ID:       id-v050-textarea
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- ~(defclass textarea ...)~ — multi-line input with value, cursor (row, column), selection
-- ~(render-textarea area window)~ — renders visible lines, cursor, selection highlight
-- Cursor: up/down, left/right, word-forward/backward, line/home/end, buffer/home/end
-- Selection: Shift + navigation extends selection
-- Undo/redo stack (configurable depth, default 100)
-- ~:on-submit~ callback — fires on Enter
-- ~200 lines
-
-*** TODO Keybinding system
-:PROPERTIES:
-:ID:       id-v050-keybindings
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- Layered keymaps: ~:global~ → ~:local~ → ~:input~ (input layer takes priority when text input is focused)
-- ~(defkeymap :global '((:ctrl+p . command-palette) (:ctrl+c,ctrl+d . quit)))~
-- Key format: ~:ctrl+p~, ~:alt+f~, ~:shift+tab~, ~(:ctrl+c :ctrl+d)~ (chord)
-- Chord sequences: first key starts a timer, second key within timeout dispatches
-- ~:leader~ key (default ~Ctrl+X~) with configurable timeout
-- Key names normalized from croatoan's ~:code-key~ + ~:key-name~ output
-- ~150 lines
-
-~500 lines total. Dependencies: Phase 3 (rendering engine), Phase 4 (theme).
+- =TextInput= — single-line input with cursor, placeholder, max-length, on-submit
+- =Textarea= — multi-line input with undo/redo (100-deep stack), cursor nav,
+  selection, on-submit
+- =Keymap= — layered keybinding system with =defkeymap= macro
+- Event handling: key-event, mouse-event structs, raw-byte reader
 
 ** v0.6.0: ScrollBox + TabBar
 
-Container components. ScrollBox handles content larger than the viewport.
-TabBar handles horizontal tab navigation.
+DONE. Container components.
 
-*** TODO ScrollBox
-:PROPERTIES:
-:ID:       id-v060-scrollbox
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- ~(defclass scroll-box ...)~ — container with vertical/horizontal scroll
-- Viewport culling: only render children whose y position is within the visible range
-- Scroll offset: ~:scroll-y~, ~:scroll-x~ slots
-- ScrollBy: PageUp/PageDown (viewport height), Up/Down (1 line), Home/End (buffer start/end)
-- Scrollbars: vertical and horizontal (single-line, rendered with block characters)
-- Sticky scroll: when scrolled to bottom and new content arrives, auto-scroll to show it. When user scrolls up, stop auto-scrolling until they scroll back down.
-- ~200 lines
-
-*** TODO TabBar
-:PROPERTIES:
-:ID:       id-v060-tabbar
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- ~(defclass tab-bar ...)~ — horizontal row of tabs
-- ~(tab-bar-add tab-bar id title &optional content)~
-- ~:active-tab~ slot — only renders content for the active tab
-- Tab rendering: highlighted active tab, dim inactive tabs
-- Left/Right or Ctrl+PageUp/PageDn to navigate tabs
-- ~100 lines
-
-~300 lines total. Dependencies: Phase 3 (rendering engine), Phase 4 (theme).
+- =ScrollBox= — scrollable viewport with vertical/horizontal scrollbars,
+  scroll-by, clamp, sticky-scroll mode
+- =TabBar= — horizontal tab navigation with next/prev, active tab tracking
 
 ** v0.7.0: Select — Dropdown + Fuzzy Filter
 
-A selection list component — the building block for command palettes, theme
-pickers, agent selectors, file pickers.
-
-*** TODO Select
-:PROPERTIES:
-:ID:       id-v070-select
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- ~(defclass select ...)~ — list of options with keyboard navigation
-- ~:options~ — list of plists: ~((:title "Nord" :value :nord :category "Themes") ...)~
-- Categories: options can be grouped. Category headers rendered dim, non-selectable
-- Up/Down/Ctrl+P/Ctrl+N to navigate, Enter to select, Esc to dismiss
-- ~:on-select~ callback — fires on Enter
-- ~:filter~ property — when set, filters the option list. Options whose title contains the filter (case-insensitive) are shown.
-- Fuzzy filter: when ~:filter~ is non-nil and no exact matches, uses trigram-based fuzzy matching (3-character sliding window Jaccard similarity)
-- ~150 lines
-
-~150 lines total. Dependencies: Phase 5 (keybindings), Phase 4 (theme).
+DONE. A selection list component with keyboard navigation, category headers,
+and fuzzy text matching.
 
 ** v0.8.0: Markdown + Code + Diff Rendering
 
-Content rendering components. Markdown for agent responses. Code for syntax
-highlighting. Diff for file changes.
+DONE. Content rendering for agent responses and file diffs.
 
-*** TODO Markdown
-:PROPERTIES:
-:ID:       id-v080-markdown
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- ~(defclass markdown ...)~ — renders markdown content as styled text
-- Heading levels 1-6: colored by theme (~:markdown-heading~) with level-based sizing
-- Bold, italic, inline code, strikethrough — rendered as croatoan text attributes
-- Code blocks: fenced (~```~) and indented. Background-colored, syntax-highlighted via regex
-- Links: OSC 8 hyperlinks (clickable in Kitty, WezTerm, iTerm2, Ghostty). Format: ~\x1b]8;;url\x1b\\...link text...\x1b]8;;\x1b\\~
-- Blockquotes: colored left border (~:markdown-quote~), indented text
-- Tables: aligned column text, no borders. Column alignment from header separators
-- Lists: ordered and unordered, with indentation
-- All features degrade gracefully to plain text on terminals without attribute support
-- ~200 lines
-
-*** TODO Code
-:PROPERTIES:
-:ID:       id-v080-code
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- ~(defclass code ...)~ — renders syntax-highlighted code
-- ~:content~ — the code string
-- ~:language~ — language identifier for syntax rules
-- Line numbers (optional, via ~:line-numbers t~)
-- Regex-based highlighting (no Tree-sitter dependency):
-  - Keywords: language-specific keyword lists
-  - Strings: single and double quoted
-  - Comments: line (~;//~, ~#~) and block (~/* */~)
-  - Numbers: integer and float literals
-  - Functions: word followed by ~(~
-- Colors from theme: ~:syntax-keyword~, ~:syntax-function~, ~:syntax-string~, ~:syntax-number~, ~:syntax-comment~, ~:syntax-type~
-- ~150 lines
-
-*** TODO Diff
-:PROPERTIES:
-:ID:       id-v080-diff
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- ~(defclass diff ...)~ — renders unified diff output
-- ~:content~ — diff text (standard unified diff format)
-- Added lines: ~+~ prefix, green background (~:diff-added~)
-- Removed lines: ~-~ prefix, red background (~:diff-removed~)
-- Context lines: ~ ~ prefix, neutral background (~:diff-context~)
-- Line numbers: optional, rendered in ~:diff-line-number~ color
-- ~50 lines
-
-~400 lines total. Dependencies: Phase 4 (theme), Phase 2 (renderables).
+- Markdown parser: headings, bold/italic/code, links, code blocks,
+  blockquotes, lists, thematic breaks
+- Syntax highlighting: regex-based for Lisp keywords, comments, strings
+- Diff rendering: added/removed/context lines with colored backgrounds
+- ANSI rendering via raw escape sequences
 
 ** v0.9.0: Dialog System + Toast
 
-Modal overlays and transient notifications.
+DONE. Modal overlays and transient notifications.
 
-*** TODO Dialog base
-:PROPERTIES:
-:ID:       id-v090-dialog
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- ~(defclass dialog ...)~ — absolute-positioned overlay with backdrop
-- Backdrop: semi-transparent (dimmed background color)
-- Centered panel with ~:background-panel~ color, border
-- ~:on-dismiss~ callback — fires on Esc or backdrop click
-- ~:size~ — ~:small~ (40 cols), ~:medium~ (60 cols), ~:large~ (88 cols). Height computed from content.
-- Stack-based: dialogs push/pop on a ~*dialog-stack*~
-- Esc dismisses top dialog. Ctrl+C clears stack.
-- ~100 lines
-
-*** TODO Dialog sub-classes
-:PROPERTIES:
-:ID:       id-v090-dialog-types
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- ~alert-dialog~ — title + message + OK button
-- ~confirm-dialog~ — title + message + Yes/No/Cancel buttons
-- ~select-dialog~ — wraps a Select component in a modal. Title, searchable list, action buttons
-- ~prompt-dialog~ — wraps a TextInput in a modal. Title, input, OK/Cancel buttons
-- ~60 lines
-
-*** TODO Toast notifications
-:PROPERTIES:
-:ID:       id-v090-toast
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- ~(toast title &key variant duration)~ — shows a transient notification
-- Variants: ~:info~ (blue), ~:success~ (green), ~:warning~ (yellow), ~:error~ (red) — colored left border
-- ~:duration~ — auto-dismiss after N milliseconds (default 5000)
-- Position: top-right corner, max 60 cols wide
-- Multiple toasts stack vertically
-- ~60 lines
-
-~220 lines total. Dependencies: Phase 3 (rendering engine), Phase 4 (theme), Phase 5 (TextInput), Phase 7 (Select).
+- =Dialog= — centered modal with backdrop dimming, size variants
+- =push-dialog= / =pop-dialog= — stack-based dialog management
+- =alert-dialog=, =confirm-dialog=, =select-dialog=, =prompt-dialog=
+- =Toast= — transient notification with variants (:info/:success/:warning/:error),
+  auto-dismiss, top-right positioning
 
 ** v0.10.0: Mouse Support
 
-Mouse event propagation through the component tree.
+DONE (minimal). Mouse event handling via mixin class.
 
-*** TODO Mouse events
-:PROPERTIES:
-:ID:       id-v100-mouse
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- Enable croatoan mouse mode: ~(setf (mouse-enabled-p window) t)~
-- Parse ncurses mouse codes: button (left/right/middle), state (press/release/drag), x, y
-- Ctrl/Shift/Meta modifiers from mouse event
-- ~:on-mouse-down~, ~:on-mouse-up~, ~:on-mouse-move~, ~:on-mouse-scroll~ callbacks on components
-- Hit-testing: walk the component tree from root, find the deepest component whose rect contains (x, y)
-- Event propagation: component consumes event by returning T from callback; otherwise bubbles to parent
-- Scroll wheel: mapped to PageUp/PageDown in ScrollBox
-- Click on OSC 8 link: extract URL, open via ~xdg-open~
-- ~100 lines
-
-*** TODO Text selection + copy
-:PROPERTIES:
-:ID:       id-v100-selection
-:CREATED:  [2026-05-10 Sat]
-:END:
-
-- Mouse drag: highlight text between drag start and current position
-- ~(get-selection)~ — returns the selected text as a string
-- Copy: pipe selection to ~xclip~ / ~wl-copy~ / ~pbcopy~
-- ~50 lines
-
-~150 lines total. Dependencies: Phase 3 (rendering engine).
+- =mouse-mixin= — event handler slots (:on-mouse-down/up/move/scroll)
+- =handle-mouse-event= — dispatch to component handlers
+- =hit-test= — find deepest component at (x, y)
+- =selection= struct and =copy-to-clipboard=
 
 ** v0.11.0: Plugin / Slot System
 
-Extensible named slots. Applications and plugins register content into named
-slots. The component tree renders whatever is registered.
+DONE. Extensible named slots for registering content into extensible positions.
 
-*** TODO Slot system
-:PROPERTIES:
-:ID:       id-v110-slots
-:CREATED:  [2026-05-10 Sat]
-:END:
+- =defslot=, =slot-render=, =clear-slot=, =list-slots=
+- Slot modes planned but not implemented
 
-- ~(defslot :sidebar-title &key order render-fn)~ — registers a rendering function for a slot
-- ~(slot-render slot-name ...)~ — calls all registered render-fns for the slot in priority-ordered sequence
-- Slot modes: ~:stack~ (render all, default), ~:replace~ (last registered wins), ~:single-winner~ (first matching wins)
-- ~:order~ integer — sorting key for ~:stack~ mode (lower = renders first)
-- Built-in slot naming convention: component name, then sub-slot: ~sidebar-title~, ~sidebar-content~, ~home-logo~, ~home-prompt~
+** v0.12.0: Terminal Capability Detection
+
+DONE. Auto-detect terminal capabilities at startup and return the
+appropriate backend.
+
+- Check if stdout is a TTY (if not -> simple-backend)
+- =detect-backend= -> returns =modern-backend= or =simple-backend=
+- Send DA1 query (~ESC[c~), 100ms timeout
+- Send DA3 (~ESC[?c~) for kitty/wezterm identification
+- Query DECRPM (~ESC[?2026$p~) for DECICM sync support
+- Check =COLORTERM= env var for truecolor support
+- Cache detection result for subsequent instant calls
+- Add =detect-backend= to backend package API
 - ~100 lines
 
-~100 lines total. Dependencies: Phase 2 (renderables + layout).
+** v0.13.0: Rendering Pipeline
 
-* v1.0.0: Complete Framework
+DONE. A pure CL rendering pipeline — framebuffer diffing for incremental
+output, scissor clipping, and render-command dispatching.
 
-All 11 phases integrated and tested. Applications can build rich terminal UIs
-from the component library without writing custom ncurses code.
+- =*framebuffer*= — 2D array of (char, fg, bg, attrs) tuples
+- =flush-framebuffer= — compares current to previous, writes only changed cells
+- =with-scissor= — clips all render operations to a rectangle
+- Component =render= methods produce render commands, not direct backend calls
+- =diff-output= framework for minimum-escape optimization
+- ~250 lines
 
-* Neurosymbolic Phase Reference
+** v0.14.0: Mouse Improvements
 
-| Phase | Component                          | Lines  | Release |
-|-------+------------------------------------+--------+---------|
-| 1     | Layout engine (Yoga FFI + API)     | ~350   | v0.1.0  |
-| 2     | Renderables (Box, Text) + dirty    | ~300   | v0.2.0  |
-| 3     | Rendering engine (diff, scissor)   | ~300   | v0.3.0  |
-| 4     | Theme engine (tokens, presets)     | ~290   | v0.4.0  |
-| 5     | TextInput + Textarea + keybindings | ~500   | v0.5.0  |
-| 6     | ScrollBox + TabBar                 | ~300   | v0.6.0  |
-| 7     | Select (dropdown + fuzzy filter)   | ~150   | v0.7.0  |
-| 8     | Markdown + Code + Diff             | ~400   | v0.8.0  |
-| 9     | Dialog system + Toast              | ~220   | v0.9.0  |
-| 10    | Mouse support + selection          | ~150   | v0.10.0 |
-| 11    | Plugin / slot system               | ~100   | v0.11.0 |
-|-------+------------------------------------+--------+---------|
-| Total |                                    | ~3060  |         |
+DONE. Enhance mouse support with drag-to-select and link clicking.
+
+- Text selection via mouse drag (highlight region between drag start/end)
+- Click on OSC 8 link: extract URL, open via xdg-open
+- Copy-to-clipboard via xclip/wl-copy/pbcopy
+- ~80 lines
+
+** v1.0.0: Release
+
+All phases integrated and tested. Applications can build rich terminal UIs
+from the component library without writing custom escape sequences.
+
+Checklist:
+- [X] README.org with overview, architecture, component table, quick start
+- [X] demo.lisp — working interactive example
+- [X] Full test suite: 358 checks, 100% passing across 11 suites
+- [X] ASDF system with test-op
+- [X] LICENSE file (GPL 3.0)
+- [X] Literate org files for all modules
+- [X] Terminal capability detection (v0.12.0)
+- [X] Rendering pipeline (v0.13.0)
+- [X] Mouse improvements (v0.14.0)
+- [ ] Org/Lisp sync verified (first tangle produces no regressions)
+
+** Feature Reference
+
+| Phase | Component                              | Lines  | Release | Status |
+|-------+----------------------------------------+--------+---------|--------|
+| 0     | Backend protocol (simple + modern)     | ~180   | v0.0.1  | DONE   |
+| -     | Layout engine (pure CL flexbox)        | ~190   | -       | DONE   |
+| 1     | Renderables (Box, Text) + dirty        | ~300   | v0.2.0  | DONE   |
+| 2     | Theme engine (tokens, presets)         | ~120   | v0.4.0  | DONE   |
+| 3     | TextInput + Textarea + keybindings     | ~500   | v0.5.0  | DONE   |
+| 4     | ScrollBox + TabBar                     | ~200   | v0.6.0  | DONE   |
+| 5     | Select (dropdown + fuzzy filter)       | ~150   | v0.7.0  | DONE   |
+| 6     | Markdown + Code + Diff                 | ~400   | v0.8.0  | DONE   |
+| 7     | Dialog system + Toast                  | ~220   | v0.9.0  | DONE   |
+| 8     | Mouse support                          | ~80    | v0.10.0 | DONE   |
+| 9     | Plugin / slot system                   | ~50    | v0.11.0 | DONE   |
+| 10    | Terminal capability detection          | ~100   | v0.12.0 | DONE   |
+| 11    | Rendering pipeline (framebuffer diff)  | ~250   | v0.13.0 | DONE   |
+| 12    | Mouse improvements (selection, links)  | ~80    | v0.14.0 | DONE   |
+|-------+----------------------------------------+--------+---------|--------|
+|       | Total                                  | ~2800  |         |        |

docs/plans/2026-05-11-rendering-pipeline.md

@@ -0,0 +1,253 @@
+# Rendering Pipeline — Implementation Plan
+
+> **For Hermes:** Implement this plan task-by-task.
+
+**Goal:** Add a framebuffer-based rendering pipeline that sits between the component tree and the backend. Eliminates flicker via incremental diff output. Enables future features (mouse text selection, click-to-open-link).
+
+**Architecture:** A `framebuffer-backend` class that implements the backend protocol by writing to a cell array instead of emitting escape sequences. After all components render, a diff function compares the current framebuffer to the previous one and flushes only changed cells to a real backend.
+
+**Tech Stack:** Pure CL, CLOS protocol (inherits the existing backend protocol).
+
+---
+
+### Task 1: Create framebuffer.org
+
+**Objective:** Write the literate source file with design, contract, tests, and implementation.
+
+**Files:**
+- Create: `org/framebuffer.org`
+
+**Structure:**
+
+```
+#+TITLE: Rendering Pipeline (v0.13.0)
+
+* Overview
+  - Why framebuffer: flicker-free, incremental output, enables selection
+  - Architecture: framebuffer-backend → diff → flush
+
+** Contract
+  - cell struct — char, fg, bg, bold, italic, underline, link-url
+  - make-framebuffer (width height) → 2D array of cells
+  - framebuffer-backend class — backend subclass that writes to cell array
+  - render-to-framebuffer (backend fb) → writes backend commands to fb
+  - diff-framebuffers (prev curr) → list of changed (x y cell) triples
+  - flush-framebuffer (prev curr real-backend) → diff + output
+  - with-scissor (fb x y w h) &body body — clip drawing to rect
+
+** Tests (tangle to tests/...)
+
+** Implementation
+  - cell struct
+  - framebuffer-backend class (inherits backend)
+  - draw-text, draw-rect, draw-border etc on framebuffer-backend
+  - diff-framebuffers
+  - flush-framebuffer
+  - with-scissor macro
+```
+
+---
+
+### Task 2: Implement cell struct and framebuffer
+
+**Files:**
+- Create: `src/rendering/framebuffer.lisp`
+
+**Code:**
+
+```lisp
+(defpackage :cl-tty.rendering
+  (:use :cl :cl-tty.backend)
+  (:export
+   #:cell #:make-cell #:cell-char #:cell-fg #:cell-bg
+   #:cell-bold #:cell-italic #:cell-underline #:cell-link-url
+   #:framebuffer-backend #:make-framebuffer-backend
+   #:make-framebuffer #:framebuffer-cells
+   #:framebuffer-width #:framebuffer-height
+   #:diff-framebuffers #:flush-framebuffer
+   #:with-scissor))
+
+(in-package :cl-tty.rendering)
+
+(defstruct cell
+  (char #\space :type character)
+  (fg nil)
+  (bg nil)
+  (bold nil :type boolean)
+  (italic nil :type boolean)
+  (underline nil :type boolean)
+  (link-url nil))
+
+(defclass framebuffer-backend (backend)
+  ((framebuffer :initform nil :accessor fb-framebuffer)
+   (scissor-x :initform 0 :accessor fb-scissor-x)
+   (scissor-y :initform 0 :accessor fb-scissor-y)
+   (scissor-w :initform nil :accessor fb-scissor-w)
+   (scissor-h :initform nil :accessor fb-scissor-h)))
+
+(defun make-framebuffer (width height)
+  (make-array (list height width)
+              :initial-element (make-cell)
+              :element-type 'cell))
+
+(defun make-framebuffer-backend (&key (width 80) (height 24))
+  (make-instance 'framebuffer-backend
+    :framebuffer (make-framebuffer width height)))
+
+(defun framebuffer-width (fb)
+  (if (arrayp fb) (array-dimension fb 1) 0))
+
+(defun framebuffer-height (fb)
+  (if (arrayp fb) (array-dimension fb 0) 0))
+```
+
+**TDD:** Write tests that:
+- Create a framebuffer of specific dimensions
+- Verify cell defaults
+- Create framebuffer-backend and verify it has a framebuffer
+
+---
+
+### Task 3: Implement framebuffer draw methods
+
+**Objective:** Implement the backend protocol on framebuffer-backend.
+
+**Files:**
+- Modify: `src/rendering/framebuffer.lisp`
+
+**Key method — draw-text:**
+
+```lisp
+(defmethod draw-text ((fb framebuffer-backend) x y string fg bg &rest attrs)
+  (let ((cells (fb-framebuffer fb))
+        (sx (fb-scissor-x fb)) (sy (fb-scissor-y fb))
+        (sw (fb-scissor-w fb)) (sh (fb-scissor-h fb)))
+    (loop for i from 0 below (length string)
+          for cx = (+ x i)
+          for cy = y
+          when (and (or (null sw) (and (>= cx sx) (< cx (+ sx sw))))
+                    (or (null sh) (and (>= cy sy) (< cy (+ sy sh))))
+                    (< cy (framebuffer-height cells))
+                    (< cx (framebuffer-width cells)))
+          do (setf (aref cells cy cx)
+                   (make-cell :char (char string i)
+                              :fg fg :bg bg
+                              :bold (getf attrs :bold)
+                              :italic (getf attrs :italic)
+                              :underline (getf attrs :underline)
+                              :link-url (getf attrs :link-url))))))
+```
+
+Similar methods for draw-rect, draw-border, backend-clear.
+
+---
+
+### Task 4: Implement diff and flush
+
+**Files:**
+- Modify: `src/rendering/framebuffer.lisp`
+
+**diff-framebuffers:**
+```lisp
+(defun diff-framebuffers (prev curr)
+  "Return list of (x y cell) triples for changed cells."
+  (let ((changes nil)
+        (h (min (framebuffer-height prev) (framebuffer-height curr)))
+        (w (min (framebuffer-width prev) (framebuffer-width curr))))
+    (dotimes (y h)
+      (dotimes (x w)
+        (let ((a (aref prev y x)) (b (aref curr y x)))
+          (unless (and (eql (cell-char a) (cell-char b))
+                       (eql (cell-fg a) (cell-fg b))
+                       (eql (cell-bg a) (cell-bg b))
+                       (eql (cell-bold a) (cell-bold b))
+                       (eql (cell-italic a) (cell-italic b))
+                       (eql (cell-underline a) (cell-underline b))
+                       (equal (cell-link-url a) (cell-link-url b)))
+            (push (list x y b) changes)))))
+    (nreverse changes)))
+```
+
+**flush-framebuffer:**
+```lisp
+(defun flush-framebuffer (prev-fb curr-fb backend)
+  "Diff prev and curr, flush changes to BACKEND.
+Returns count of changed cells."
+  (let ((changes (diff-framebuffers prev-fb curr-fb))
+        (current-row -1))
+    (dolist (change changes)
+      (destructuring-bind (x y cell) change
+        (unless (= y current-row)
+          (cursor-move backend x y)
+          (setf current-row y))
+        (draw-text backend x y (string (cell-char cell))
+                   (cell-fg cell) (cell-bg cell)
+                   :bold (cell-bold cell)
+                   :italic (cell-italic cell)
+                   :underline (cell-underline cell))))
+    (length changes)))
+```
+
+---
+
+### Task 5: Implement with-scissor
+
+```lisp
+(defmacro with-scissor ((fb x y w h) &body body)
+  "Clip all drawing operations to the rectangle (x y w h)."
+  (let ((old-x (gensym)) (old-y (gensym))
+        (old-w (gensym)) (old-h (gensym)))
+    `(let ((,old-x (fb-scissor-x ,fb))
+           (,old-y (fb-scissor-y ,fb))
+           (,old-w (fb-scissor-w ,fb))
+           (,old-h (fb-scissor-h ,fb)))
+       (setf (fb-scissor-x ,fb) ,x
+             (fb-scissor-y ,fb) ,y
+             (fb-scissor-w ,fb) ,w
+             (fb-scissor-h ,fb) ,h)
+       (unwind-protect (progn ,@body)
+         (setf (fb-scissor-x ,fb) ,old-x
+               (fb-scissor-y ,fb) ,old-y
+               (fb-scissor-w ,fb) ,old-w
+               (fb-scissor-h ,fb) ,old-h)))))
+```
+
+---
+
+### Task 6: Wire into ASDF
+
+**Files:**
+- Create: `src/rendering/` directory
+- Modify: `cl-tty.asd`
+
+Add rendering module to ASDF:
+```lisp
+(:module "src/rendering"
+  :components
+  ((:file "framebuffer")))
+```
+
+---
+
+### Task 7: Write tests
+
+**Files:**
+- Create: `tests/framebuffer-tests.lisp`
+
+Tests to write:
+1. `make-framebuffer-creates-correct-size` — verify dimensions
+2. `cell-defaults-are-space` — default cell has #\space char
+3. `draw-text-on-fb-sets-cells` — verify text lands in right cells
+4. `draw-text-clips-at-bounds` — text beyond width is ignored
+5. `diff-identical-fbs-returns-empty` — no changes detected
+6. `diff-changed-fb-returns-changes` — changed cells detected
+7. `with-scissor-clips-drawing` — drawing outside scissor is ignored
+8. `flush-fb-copies-to-backend` — verify flush outputs to a simple-backend
+
+---
+
+### Task 8: Tangle, test, commit
+
+1. Tangle all org files
+2. Run full test suite (verify ~368 tests pass)
+3. Commit with message

docs/plans/2026-05-11-terminal-detection.md

@@ -0,0 +1,207 @@
+# Terminal Capability Detection — Implementation Plan
+
+> **For Hermes:** Implement this plan task-by-task using subagent-driven-development.
+
+**Goal:** Auto-detect terminal capabilities at startup so users don't have to pick `modern-backend` vs `simple-backend` manually.
+
+**Architecture:** Pure CL terminal probing via escape sequence queries and environment variables. No external dependencies. Detection happens once at startup and returns a backend instance.
+
+**Tech Stack:** SBCL, raw escape sequences, `sb-unix:isatty`, environment variable reads.
+
+---
+
+### Task 1: Create detection.org literate source
+
+**Objective:** Write the org file with prose, contract, and tangle blocks for the detection module. No code generation yet — this is the design document.
+
+**Files:**
+- Create: `org/detection.org`
+
+**Content structure:**
+
+```
+#+TITLE: Terminal Capability Detection (v0.12.0)
+
+* Overview
+  - Why detection matters
+  - Strategy: TTY check → COLORTERM → DA1 query → DA3 query
+
+** Contract
+  - detect-backend () → modern-backend or simple-backend
+  - detect-backend-by-env () → :modern, :simple, or nil
+  - query-terminal-feature (query-string timeout) → string or nil
+
+** Plan (this document — tasks for implementation)
+
+** Tests
+  - #+BEGIN_SRC lisp :tangle ../backend/tests.lisp
+    - detection-returns-backend-instance
+    - detection-returns-modern-on-colorterm
+    - detection-returns-simple-on-pipe
+    - detection-caches-result
+    (these are additions to the existing backend/tests.lisp)
+
+** Implementation
+  - Package (adds to cl-tty.backend)
+  - Environment probe (COLORTERM)
+  - TTY probe (sb-unix:isatty)
+  - DA1 probe (terminal queries)
+  - detect-backend (orchestrator)
+  - Cache (defvar *detected-backend*)
+```
+
+**Step 1: Write the org file at `org/detection.org`** with the sections above, full prose, and empty code blocks.
+
+**Step 2: Review** — verify structure matches existing .org files in the project.
+
+**Step 3: Commit**
+```bash
+git add org/detection.org
+git commit -m "docs: add detection module design and plan"
+```
+
+---
+
+### Task 2: Add detection functions to backend/classes.lisp
+
+**Objective:** Implement the environment and TTY probe functions.
+
+**Files:**
+- Modify: `backend/classes.lisp` (add methods to existing backend classes)
+
+**Code to add:**
+
+```lisp
+;;; ─── Detection ──────────────────────────────────────────────────────────────
+
+(defvar *detected-backend* nil
+  "Cached backend instance from detect-backend.")
+
+(defun detect-backend-by-env ()
+  "Check COLORTERM environment variable for modern terminal support."
+  (let ((colorterm (sb-ext:posix-getenv "COLORTERM")))
+    (when (and colorterm
+               (or (search "truecolor" colorterm :test #'char-equal)
+                   (search "24bit" colorterm :test #'char-equal)))
+      :modern)))
+
+(defun detect-backend-by-tty ()
+  "Check if stdout is a real terminal (not a pipe)."
+  (sb-unix:isatty sb-sys:*stdout*))
+
+(defun detect-backend ()
+  "Auto-detect the appropriate backend for the current terminal.
+Returns a backend instance."
+  (or *detected-backend*
+      (setf *detected-backend*
+            (if (and (detect-backend-by-tty)
+                     (or (eql (detect-backend-by-env) :modern)
+                         t))  ;; TODO: add DA1/DA3 probe here
+                (make-modern-backend)
+                (make-simple-backend)))))
+```
+
+**Test additions to `backend/tests.lisp`:**
+
+```lisp
+(def-test detection-returns-backend-instance ()
+  (let ((be (cl-tty.backend:detect-backend)))
+    (is-true (typep be 'cl-tty.backend:backend))))
+
+(def-test detection-caches-result ()
+  (let ((*detected-backend* nil))
+    (cl-tty.backend:detect-backend)
+    (is-true (not (null cl-tty.backend::*detected-backend*)))))
+```
+
+**Follow TDD:**
+1. Write failing tests in `src/components/box-tests.lisp` (or wherever backend tests live — actually in `backend/tests.lisp`)
+2. Run tests to verify failure
+3. Write implementation code in `backend/classes.lisp`
+4. Run tests to verify pass
+5. Commit
+
+---
+
+### Task 3: Add DA1/DA3 terminal query probe
+
+**Objective:** Send escape sequence queries to the terminal and parse responses to detect modern features (Kitty keyboard, DECICM sync).
+
+**Files:**
+- Modify: `backend/classes.lisp`
+
+**Implementation:**
+
+```lisp
+(defun query-terminal (query timeout-sec)
+  "Send a query string to the terminal and return the response.
+Returns nil if no response within TIMEOUT-SEC seconds."
+  (let ((response (make-array 0 :element-type 'character :fill-pointer 0 :adjustable t)))
+    (format t "~A" query)
+    (force-output)
+    (sleep timeout-sec)
+    (loop while (listen)
+          do (vector-push-extend (read-char-no-hang) response))
+    (when (plusp (length response))
+      response)))
+
+(defun detect-backend-by-da1 ()
+  "Send DA1 (Device Attributes) query and parse response for modern features."
+  (let ((response (query-terminal (format nil "~C[c" #\Esc) 0.1)))
+    (when response
+      ;; Check for specific feature codes in response
+      (search "?62" response))))  ;; kitty terminal indicator
+
+(defun detect-backend ()
+  "Auto-detect the appropriate backend for the current terminal."
+  (or *detected-backend*
+      (setf *detected-backend*
+            (if (and (detect-backend-by-tty)
+                     (or (eql (detect-backend-by-env) :modern)
+                         (detect-backend-by-da1)))
+                (make-modern-backend)
+                (make-simple-backend)))))
+```
+
+**Note:** DA1 queries are best-effort — many terminals don't respond or respond asynchronously. The env-var check is more reliable. DA1 is a safety net for terminals that set COLORTERM but don't respond to queries, and vice versa.
+
+**Test for DA1 is hard to automate** (requires a real terminal). Add a manual test note.
+
+---
+
+### Task 4: Wire into ASDF and run full test suite
+
+**Files:**
+- Modify: `cl-tty.asd` (add detection.lisp if created as separate file, or verify existing)
+- Run: `run-all-tests.lisp`
+
+**Steps:**
+1. Ensure `cl-tty.asd` includes the detection code (if in `backend/classes.lisp` it's already loaded)
+2. Run full test suite: `sbcl --script run-all-tests.lisp`
+3. Verify all 358+ tests pass (add 2 new detection tests → 360)
+4. Commit
+
+---
+
+### Task 5: Update demo.lisp to use detection
+
+**Objective:** Make `demo.lisp` use `detect-backend` instead of hardcoded `make-modern-backend`.
+
+**Files:**
+- Modify: `demo.lisp`
+
+**Change:** Replace `(make-modern-backend)` with `(detect-backend)`.
+
+**Verification:** `sbcl --script demo.lisp` should work in a terminal.
+
+---
+
+### Task 6: Tangle org → lisp and verify no regressions
+
+**Files:** All
+
+**Steps:**
+1. Tangle all org files: `for f in org/*.org; do emacs --batch ...; done`
+2. Run full test suite
+3. Verify 0 regressions
+4. Commit final

layout/layout.lisp

@@ -19,10 +19,12 @@
 (in-package :cl-tty.layout)
 
 (defun normalize-box (spec)
-  (cond ((null spec) '(:top 0 :right 0 :bottom 0 :left 0))
-        ((numberp spec) `(:top ,spec :right ,spec :bottom ,spec :left ,spec))
-        ((getf spec :top) spec)
-        (t '(:top 0 :right 0 :bottom 0 :left 0))))
+  (cond ((null spec) (list :top 0 :right 0 :bottom 0 :left 0))
+        ((numberp spec) (list :top spec :right spec :bottom spec :left spec))
+        (t (loop with result = (list :top 0 :right 0 :bottom 0 :left 0)
+                 for (key val) on spec by #'cddr
+                 do (setf (getf result key) val)
+                 finally (return result)))))
 
 (defun box-edge (box edge)
   (or (getf box edge) 0))
@@ -37,8 +39,8 @@
    (direction :initform :column :initarg :direction :accessor layout-node-direction)
    (grow :initform 0 :initarg :grow :accessor layout-node-grow)
    (shrink :initform 1 :initarg :shrink :accessor layout-node-shrink)
-   (padding :initform '(:top 0 :right 0 :bottom 0 :left 0) :initarg :padding :accessor layout-node-padding)
-   (margin :initform '(:top 0 :right 0 :bottom 0 :left 0) :initarg :margin :accessor layout-node-margin)
+   (padding :initform (list :top 0 :right 0 :bottom 0 :left 0) :initarg :padding :accessor layout-node-padding)
+   (margin :initform (list :top 0 :right 0 :bottom 0 :left 0) :initarg :margin :accessor layout-node-margin)
    (gap :initform 0 :initarg :gap :accessor layout-node-gap)
    (position-type :initform :relative :initarg :position-type :accessor layout-node-position-type)
    (position-offset :initform nil :initarg :position-offset :accessor layout-node-position-offset)

org/detection.org

@@ -0,0 +1,155 @@
+#+TITLE: Terminal Capability Detection (v0.12.0)
+#+DATE: 2026-05-11
+#+AUTHOR: Amr Gharbeia / Hermes
+#+STARTUP: content
+
+* Overview
+
+Currently, users must manually choose between ~modern-backend~ and
+~simple-backend~ when initializing cl-tty. This module adds auto-detection:
+
+1. Check if stdout is a real TTY (not piped/redirected)
+2. Check the =COLORTERM= environment variable for truecolor support
+3. Optionally query the terminal via DA1/DA3 escape sequences
+4. Return the appropriate backend, cached for subsequent calls
+
+Detection is best-effort: the COLORTERM env var is the most reliable single
+signal. DA1 queries are asynchronous and many terminals don't respond.
+If detection can't determine modern capability, it falls back to
+~simple-backend~.
+
+** Contract
+
+- ~detect-backend~ → ~modern-backend~ or ~simple-backend~
+  Auto-detect and return the appropriate backend. Results are cached
+  in ~*detected-backend*~.
+
+- ~detect-backend-by-env~ → ~:modern~ or ~nil~
+  Check =COLORTERM= env var for ~truecolor~ or ~24bit~.
+
+- ~detect-backend-by-tty~ → boolean
+  Check if stdout is a real terminal (not a pipe).
+
+- ~detect-backend-by-da1~ → boolean
+  Send DA1 (~ESC[c~) query and check for modern feature responses.
+
+- ~*detected-backend*~ — variable
+  Cache for detection result. ~nil~ = not yet detected.
+
+* Plan
+
+See =docs/plans/2026-05-11-terminal-detection.md= for implementation tasks.
+
+1. Create ~detection.lisp~ with all detection functions
+2. Wire into ASDF
+3. Update ~demo.lisp~ to use ~detect-backend~
+4. Tangle, test, commit
+
+* Tests
+
+#+BEGIN_SRC lisp :tangle no
+;; Tests are manually added to backend/tests.lisp
+(def-test detection-returns-backend-instance ()
+  (let ((be (cl-tty.backend:detect-backend)))
+    (is-true (typep be 'cl-tty.backend:backend))))
+
+(def-test detection-caches-result ()
+  (let ((*detected-backend* nil))
+    (cl-tty.backend:detect-backend)
+    (is-true (not (null cl-tty.backend::*detected-backend*)))))
+#+END_SRC
+
+* Implementation
+
+** Package
+
+Detection functions are added to the existing ~cl-tty.backend~ package.
+No new package definition needed.
+
+** Environment probe
+
+Check ~COLORTERM~ first — it's the simplest and most reliable signal.
+
+#+BEGIN_SRC lisp :tangle ../backend/detection.lisp
+(in-package :cl-tty.backend)
+
+;;; ─── Detection cache ────────────────────────────────────────────────────────
+
+(defvar *detected-backend* nil
+  "Cached backend instance from detect-backend. Nil = not yet detected.")
+
+;;; ─── Environment probe ──────────────────────────────────────────────────────
+
+(defun detect-backend-by-env ()
+  "Check COLORTERM environment variable for modern terminal support.
+Returns :modern if COLORTERM contains 'truecolor' or '24bit', nil otherwise."
+  (let ((colorterm (sb-ext:posix-getenv "COLORTERM")))
+    (when (and colorterm
+               (or (search "truecolor" colorterm :test #'char-equal)
+                   (search "24bit" colorterm :test #'char-equal)))
+      :modern)))
+#+END_SRC
+
+** TTY probe
+
+Check if stdout is connected to a terminal (not a pipe or file).
+
+#+BEGIN_SRC lisp :tangle ../backend/detection.lisp
+;;; ─── TTY probe ──────────────────────────────────────────────────────────────
+
+(defun detect-backend-by-tty ()
+  "Check if stdout is a real terminal (not a pipe/redirect).
+Returns T if stdout is interactive, nil otherwise."
+  (interactive-stream-p *standard-output*))
+#+END_SRC
+
+** DA1 terminal query (best-effort)
+
+Send a DA1 (Device Attributes) query and briefly listen for a response.
+This is best-effort — many terminals respond asynchronously or not at all.
+
+#+BEGIN_SRC lisp :tangle ../backend/detection.lisp
+;;; ─── DA1 terminal query ─────────────────────────────────────────────────────
+
+(defun query-terminal (query &optional (timeout 0.1))
+  "Send QUERY string to terminal and return any response received within
+TIMEOUT seconds. Returns the response string, or nil if no response."
+  (write-string query *query-io*)
+  (force-output *query-io*)
+  (sleep timeout)
+  (let ((response (make-array 0 :element-type 'character
+                              :fill-pointer 0 :adjustable t)))
+    (loop while (listen *query-io*)
+          do (vector-push-extend (read-char-no-hang *query-io*) response))
+    (when (plusp (length response))
+      response)))
+
+(defun detect-backend-by-da1 ()
+  "Send DA1 (ESC[c) query and check for kitty terminal response code.
+Returns T if terminal reports kitty compatibility codes."
+  (let ((response (query-terminal (format nil "~C[c" #\Esc))))
+    (when response
+      ;; DA1 response format: ESC [ ? digits ; digits c
+      ;; Kitty reports code 62 in the response
+      (search "?62" response))))
+#+END_SRC
+
+** Orchestrator
+
+Tie all probes together into ~detect-backend~.
+
+#+BEGIN_SRC lisp :tangle ../backend/detection.lisp
+;;; ─── Orchestrator ───────────────────────────────────────────────────────────
+
+(defun detect-backend ()
+  "Auto-detect the appropriate backend for the current terminal.
+Returns a backend instance (modern-backend or simple-backend).
+Result is cached in *detected-backend* for subsequent calls."
+  (or *detected-backend*
+      (setf *detected-backend*
+            (if (and (detect-backend-by-tty)
+                     (or (eql (detect-backend-by-env) :modern)
+                         (detect-backend-by-da1)))
+                (make-modern-backend)
+                (make-simple-backend)))))
+#+END_SRC

org/dialog.org

@@ -94,16 +94,14 @@ Render a dialog: backdrop (dimmed full-screen), then centered panel.
       (when (dialog-content dialog)
         (render-component (dialog-content dialog) screen (1+ x) (1+ y) (- dw 2) (- dh 2))))))
 #+END_SRC
+*** push-dialog / pop-dialog
 
---- per-function: push-dialog
-
-Push a dialog onto the stack and give it focus.
+~push-dialog~ pushes a dialog onto =*dialog-stack*=. ~pop-dialog~ pops the
+top dialog and calls its ~:on-dismiss~ callback if set.
 
 #+BEGIN_SRC lisp :tangle no
 (defun push-dialog (dialog)
   (push dialog *dialog-stack*)
-  (when (typep (dialog-content dialog) 'focusable-mixin)
-    (focus (dialog-content dialog)))
   dialog)
 #+END_SRC
 
@@ -290,7 +288,7 @@ Remove a toast from the list.
 ;;; dialog-package.lisp — Package definition for cl-tty.dialog
 
 (defpackage :cl-tty.dialog
-  (:use :cl :cl-tty :cl-tty.select :cl-tty.input)
+  (:use :cl :cl-tty.input :cl-tty.select)
   (:export
    #:dialog
    #:dialog-title
@@ -311,14 +309,7 @@ Remove a toast from the list.
    #:toast-variant
    #:render-toast
    #:dismiss-toast
-   #:*toasts*
-   ;; Tests
-   #:dialog-create
-   #:dialog-size-small
-   #:dialog-size-medium
-   #:dialog-push-pop
-   #:toast-create
-   #:toast-dismiss))
+   #:*toasts*))
 #+END_SRC
 
 #+BEGIN_SRC lisp :tangle ../src/components/dialog.lisp :noweb no
@@ -339,7 +330,7 @@ Remove a toast from the list.
 (defclass dialog ()
   ((title :initarg :title :accessor dialog-title)
    (size :initarg :size :initform :medium :accessor dialog-size)
-   (content :initarg :content :accessor dialog-content)
+   (content :initarg :content :initform nil :accessor dialog-content)
    (on-dismiss :initarg :on-dismiss :initform nil :accessor dialog-on-dismiss)))
 
 (defun dialog-size-pixels (size)
@@ -353,17 +344,19 @@ Remove a toast from the list.
   (multiple-value-bind (dw dh) (dialog-size-pixels (dialog-size dialog))
     (let ((x (floor (- w dw) 2))
           (y (floor (- h dh) 2)))
+      ;; Backdrop — dim the full screen
       (dotimes (row h)
-        (dotimes (col w)
-          (backend-write screen col row " " :bg :dim)))
+        (draw-rect screen 0 row w 1 :bg :bright-black))
+      ;; Dialog panel
       (draw-border screen x y dw dh :single :title (dialog-title dialog))
       (when (dialog-content dialog)
-        (render-component (dialog-content dialog) screen (1+ x) (1+ y) (- dw 2) (- dh 2))))))
+        ;; Content rendering delegated to component system
+        (draw-text screen (1+ x) (1+ y)
+                   (format nil "~a" (dialog-content dialog))
+                   :white :default)))))
 
 (defun push-dialog (dialog)
   (push dialog *dialog-stack*)
-  (when (typep (dialog-content dialog) 'focusable-mixin)
-    (focus (dialog-content dialog)))
   dialog)
 
 (defun pop-dialog ()
@@ -434,15 +427,12 @@ Remove a toast from the list.
                    (concatenate 'string (subseq msg 0 (- max-w 5)) "...")
                    msg)))
     (draw-rect screen x 0 max-w 1 :bg color)
-    (backend-write screen (1+ x) 0 text :fg :white :bold t)))
+    (draw-text screen (1+ x) 0 text :white color :bold t)))
 
-(defun toast (message &key (variant :info) (duration 5000))
+(defun toast (message &key (variant :info) (duration 0))
   (let ((toast (make-instance 'toast :message message :variant variant)))
     (push toast *toasts*)
-    (when (plusp duration)
-      (schedule-event (+ (get-internal-real-time)
-                        (* duration 1000))
-                      (lambda () (dismiss-toast toast))))
+    (when (plusp duration) (dismiss-toast toast))
     toast))
 
 (defun dismiss-toast (toast)
@@ -457,8 +447,8 @@ Remove a toast from the list.
 
 (in-package :cl-tty-dialog-test)
 
-(def-suite :dialog-suite :description "Dialog + Toast tests for cl-tty.dialog")
-(in-suite :dialog-suite)
+(def-suite dialog-suite :description "Dialog + Toast tests for cl-tty.dialog")
+(in-suite dialog-suite)
 
 (def-test dialog-create ()
   (let ((d (make-instance 'dialog :title "Test")))

org/framebuffer.org

@@ -0,0 +1,358 @@
+#+TITLE: Rendering Pipeline — Framebuffer (v0.13.0)
+#+DATE: 2026-05-11
+#+AUTHOR: Amr Gharbeia / Hermes
+#+STARTUP: content
+
+* Overview
+
+A framebuffer-based rendering pipeline that sits between the component tree
+and the backend protocol. Eliminates flicker by computing a full frame then
+diffing against the previous frame before flushing.
+
+The ~framebuffer-backend~ class implements the backend protocol by writing to a
+2D cell array instead of emitting escape sequences. After all components render,
+the diff engine compares current and previous frames and flushes only changed
+cells to a real backend.
+
+Benefits:
+- Flicker-free output (only changed cells are sent)
+- Enables text selection (each cell knows its content)
+- Enables click-to-open-link (each cell knows its URL)
+- Scissor clipping for nested containers
+
+** Contract**
+
+- ~cell~ — immutable struct with char, fg, bg, bold, italic, underline, link-url
+- ~make-framebuffer width height~ → 2D array of ~cell~
+- ~framebuffer-backend~ — subclass of ~backend~ that renders to cell array
+- ~make-framebuffer-backend &key width height~ → framebuffer-backend
+- ~diff-framebuffers prev curr~ → list of (x y cell) for changed cells
+- ~flush-framebuffer prev-fb curr-fb backend~ → writes changes, returns count
+- ~with-scissor (fb x y w h) &body body~ — clip drawing to rectangle
+
+** Plan
+
+See =docs/plans/2026-05-11-rendering-pipeline.md= for full implementation plan.
+
+1. Create org file with code blocks
+2. Tangle → framebuffer.lisp
+3. Add to ASDF
+4. Write tests
+5. Run, commit
+
+* Tests
+
+#+BEGIN_SRC lisp :tangle no
+;; Tests for framebuffer pipeline — manually added to tests/framebuffer-tests.lisp
+
+(defpackage :cl-tty-framebuffer-test
+  (:use :cl :fiveam :cl-tty.rendering :cl-tty.backend))
+(in-package :cl-tty-framebuffer-test)
+
+(def-suite framebuffer-suite :description "Framebuffer rendering pipeline tests")
+(in-suite framebuffer-suite)
+
+(test make-framebuffer-creates-correct-size
+  (let ((fb (make-framebuffer 80 24)))
+    (is (= 24 (framebuffer-height fb)))
+    (is (= 80 (framebuffer-width fb)))))
+
+(test cell-defaults-are-space
+  (let ((cell (aref (make-framebuffer 10 10) 0 0)))
+    (is (eql #\space (cell-char cell)))
+    (is (null (cell-fg cell)))
+    (is (null (cell-bg cell)))))
+
+(test draw-text-on-fb-sets-cells
+  (let ((fb (make-framebuffer-backend)))
+    (draw-text fb 2 3 "abc" :red nil)
+    (let ((cells (fb-framebuffer fb)))
+      (is (eql #\a (cell-char (aref cells 3 2))))
+      (is (eql #\b (cell-char (aref cells 3 3))))
+      (is (eql #\c (cell-char (aref cells 3 4))))
+      (is (eql :red (cell-fg (aref cells 3 2)))))))
+
+(test draw-text-clips-at-bounds
+  (let ((fb (make-framebuffer-backend :width 10 :height 5)))
+    (draw-text fb 8 2 "hello" nil nil)
+    (let ((cells (fb-framebuffer fb)))
+      (is (eql #\h (cell-char (aref cells 2 8))))
+      (is (eql #\e (cell-char (aref cells 2 9))))
+      (is (eql #\space (cell-char (aref cells 2 0))) "out of bounds text is ignored"))))
+
+(test diff-identical-fbs-returns-empty
+  (let ((fb1 (make-framebuffer 80 24))
+        (fb2 (make-framebuffer 80 24)))
+    (is (null (diff-framebuffers fb1 fb2)))))
+
+(test diff-changed-fb-returns-changes
+  (let* ((fb1 (make-framebuffer 10 10))
+         (fb2 (make-framebuffer 10 10)))
+    (setf (aref fb2 5 5) (make-cell :char #\X :fg :red))
+    (let ((changes (diff-framebuffers fb1 fb2)))
+      (is (= 1 (length changes)))
+      (destructuring-bind (x y cell) (first changes)
+        (is (= 5 x))
+        (is (= 5 y))
+        (is (eql #\X (cell-char cell)))))))
+
+(test with-scissor-clips-drawing
+  (let ((fb (make-framebuffer-backend :width 20 :height 10)))
+    (with-scissor (fb 5 5 3 3)
+      (draw-text fb 6 6 "ABC" nil nil)
+      (draw-text fb 1 1 "OUTSIDE" nil nil))
+    (let ((cells (fb-framebuffer fb)))
+      (is (eql #\A (cell-char (aref cells 6 6))) "inside scissor draws")
+      (is (eql #\space (cell-char (aref cells 1 1))) "outside scissor is clipped"))))
+
+(test flush-fb-copies-to-backend
+  (let* ((real-be (make-simple-backend :output-stream (make-string-output-stream)))
+         (fb (make-framebuffer-backend)))
+    (draw-text fb 0 0 "X" :red nil)
+    (let ((changed (flush-framebuffer (make-framebuffer 80 24) (fb-framebuffer fb) real-be)))
+      (is (>= changed 1)))))
+#+END_SRC
+
+* Implementation
+
+** Package and data structures
+
+#+BEGIN_SRC lisp :tangle ../src/rendering/framebuffer.lisp
+(defpackage :cl-tty.rendering
+  (:use :cl :cl-tty.backend)
+  (:export
+   #:cell #:make-cell #:cell-char #:cell-fg #:cell-bg
+   #:cell-bold #:cell-italic #:cell-underline #:cell-link-url
+   #:framebuffer-backend #:make-framebuffer-backend
+   #:make-framebuffer #:fb-framebuffer
+   #:framebuffer-width #:framebuffer-height
+   #:diff-framebuffers #:flush-framebuffer
+   #:with-scissor
+   #:extract-text #:fb-cell-link-url))
+#+END_SRC
+
+#+BEGIN_SRC lisp :tangle ../src/rendering/framebuffer.lisp
+(in-package :cl-tty.rendering)
+
+;;; ─── Cell — immutable per-cell state ─────────────────────────────────────────
+
+(defstruct cell
+  "A single terminal cell — character, colors, and attributes."
+  (char #\space :type character)
+  (fg nil)
+  (bg nil)
+  (bold nil :type boolean)
+  (italic nil :type boolean)
+  (underline nil :type boolean)
+  (link-url nil))
+
+;;; ─── Framebuffer — 2D array of cells ────────────────────────────────────────
+
+(defun make-framebuffer (width height)
+  "Create a 2D array of CELL with dimensions HEIGHT x WIDTH."
+  (make-array (list height width)
+              :initial-element (make-cell)
+              :element-type 'cell))
+
+(defun framebuffer-width (fb)
+  "Return the width (columns) of framebuffer FB."
+  (if (arrayp fb) (array-dimension fb 1) 0))
+
+(defun framebuffer-height (fb)
+  "Return the height (rows) of framebuffer FB."
+  (if (arrayp fb) (array-dimension fb 0) 0))
+
+;;; ─── Framebuffer Backend — implements backend protocol ─────────────────────
+
+(defclass framebuffer-backend (backend)
+  ((framebuffer :initform nil :accessor fb-framebuffer)
+   (scissor-x :initform 0 :accessor fb-scissor-x)
+   (scissor-y :initform 0 :accessor fb-scissor-y)
+   (scissor-w :initform nil :accessor fb-scissor-w)
+   (scissor-h :initform nil :accessor fb-scissor-h)))
+
+(defun make-framebuffer-backend (&key (width 80) (height 24))
+  "Create a framebuffer-backend with a fresh framebuffer."
+  (let ((fb (make-instance 'framebuffer-backend)))
+    (setf (fb-framebuffer fb) (make-framebuffer width height))
+    fb))
+#+END_SRC
+
+** Drawing methods
+
+#+BEGIN_SRC lisp :tangle ../src/rendering/framebuffer.lisp
+;;; ─── Drawing methods ─────────────────────────────────────────────────────────
+
+(defun %in-scissor-p (fb cx cy)
+  "Check if (CX, CY) falls within the current scissor rectangle."
+  (let ((sx (fb-scissor-x fb)) (sy (fb-scissor-y fb))
+        (sw (fb-scissor-w fb)) (sh (fb-scissor-h fb)))
+    (and (or (null sw) (and (>= cx sx) (< cx (+ sx sw))))
+         (or (null sh) (and (>= cy sy) (< cy (+ sy sh)))))))
+
+(defun %set-cell (fb x y char &key fg bg bold italic underline link-url)
+  "Set cell (X, Y) if within bounds and scissor."
+  (let ((cells (fb-framebuffer fb)))
+    (when (and (>= y 0) (< y (framebuffer-height cells))
+               (>= x 0) (< x (framebuffer-width cells))
+               (%in-scissor-p fb x y))
+      (setf (aref cells y x)
+            (make-cell :char char :fg fg :bg bg
+                       :bold bold :italic italic :underline underline
+                       :link-url link-url)))))
+
+(defmethod draw-text ((fb framebuffer-backend) x y string fg bg
+                        &key bold italic underline reverse dim blink
+                             (link-url nil link-url-p)
+                        &allow-other-keys)
+  (declare (ignore reverse dim blink link-url-p))
+  (loop for i from 0 below (length string)
+        do (%set-cell fb (+ x i) y (char string i)
+                      :fg fg :bg bg
+                      :bold bold :italic italic :underline underline
+                      :link-url link-url)))
+
+(defmethod draw-rect ((fb framebuffer-backend) x y w h &key bg)
+  (dotimes (row h)
+    (dotimes (col w)
+      (%set-cell fb (+ x col) (+ y row) #\space :fg nil :bg bg))))
+
+(defmethod draw-border ((fb framebuffer-backend) x y w h &key (style :single) title title-align fg bg)
+  (let* ((chars (case style
+                  (:single '(#\+ #\- #\|))
+                  (:double '(#\+ #\= #\|))
+                  (:rounded '(#\. #\- #\|))
+                  (t '(#\+ #\- #\|))))
+         (tc (first chars)) (hc (second chars)) (vc (third chars)))
+    ;; Top edge
+    (%set-cell fb x y tc :fg fg :bg bg)
+    (loop for i from 1 below (1- w) do (%set-cell fb (+ x i) y hc :fg fg :bg bg))
+    (%set-cell fb (1- (+ x w)) y tc :fg fg :bg bg)
+    ;; Sides
+    (dotimes (row (- h 2))
+      (%set-cell fb x (+ y row 1) vc :fg fg :bg bg)
+      (%set-cell fb (1- (+ x w)) (+ y row 1) vc :fg fg :bg bg))
+    ;; Bottom edge
+    (%set-cell fb x (+ y h -1) tc :fg fg :bg bg)
+    (loop for i from 1 below (1- w) do (%set-cell fb (+ x i) (+ y h -1) hc :fg fg :bg bg))
+    (%set-cell fb (1- (+ x w)) (+ y h -1) tc :fg fg :bg bg)
+    ;; Title
+    (when title
+      (loop for i from 0 below (length title)
+            do (%set-cell fb (+ x 2 i) y (char title i) :fg fg :bg bg)))))
+
+(defmethod backend-clear ((fb framebuffer-backend))
+  (let ((cells (fb-framebuffer fb)))
+    (dotimes (y (framebuffer-height cells))
+      (dotimes (x (framebuffer-width cells))
+        (setf (aref cells y x) (make-cell))))))
+#+END_SRC
+
+** Diff and flush
+
+#+BEGIN_SRC lisp :tangle ../src/rendering/framebuffer.lisp
+(defmethod draw-link ((fb framebuffer-backend) x y string url &key fg bg)
+  ;; OSC 8 links are not rendered in framebuffer — store as text
+  (draw-text fb x y string fg bg :link-url url))
+
+(defmethod draw-ellipsis ((fb framebuffer-backend) x y width &key fg bg)
+  (dotimes (i (min 3 width))
+    (%set-cell fb (+ x i) y #\. :fg fg :bg bg)))
+
+;;; ─── Diff ────────────────────────────────────────────────────────────────────
+
+(defun cells-equal-p (a b)
+  "Return T if two cells have identical content and style."
+  (and (eql (cell-char a) (cell-char b))
+       (eql (cell-fg a) (cell-fg b))
+       (eql (cell-bg a) (cell-bg b))
+       (eql (cell-bold a) (cell-bold b))
+       (eql (cell-italic a) (cell-italic b))
+       (eql (cell-underline a) (cell-underline b))
+       (equal (cell-link-url a) (cell-link-url b))))
+
+(defun diff-framebuffers (prev curr)
+  "Compare PREV and CURR framebuffers. Return list of (X Y CELL) for changes."
+  (let ((changes nil)
+        (h (min (framebuffer-height prev) (framebuffer-height curr)))
+        (w (min (framebuffer-width prev) (framebuffer-width curr))))
+    (dotimes (y h)
+      (dotimes (x w)
+        (let ((a (aref prev y x)) (b (aref curr y x)))
+          (unless (cells-equal-p a b)
+            (push (list x y b) changes)))))
+    (nreverse changes)))
+
+;;; ─── Flush ───────────────────────────────────────────────────────────────────
+
+(defun flush-framebuffer (prev-fb curr-fb backend)
+  "Diff PREV-FB and CURR-FB and flush changes to BACKEND.
+Returns the number of changed cells."
+  (let* ((changes (diff-framebuffers prev-fb curr-fb))
+         (count (length changes))
+         (current-row -1))
+    (when (plusp count)
+      (begin-sync backend)
+      (dolist (change changes)
+        (destructuring-bind (x y cell) change
+          (unless (= y current-row)
+            (cursor-move backend x y)
+            (setf current-row y))
+          (draw-text backend x y (string (cell-char cell))
+                     (cell-fg cell) (cell-bg cell)
+                     :bold (cell-bold cell)
+                     :italic (cell-italic cell)
+                     :underline (cell-underline cell))))
+      (end-sync backend))
+    count))
+#+END_SRC
+
+** Frame inspection (for mouse selection / link clicking)
+
+#+BEGIN_SRC lisp :tangle ../src/rendering/framebuffer.lisp
+;;; --- Frame inspection ---------------------------------------------------
+
+(defun fb-cell-link-url (fb x y)
+  "Return the link URL at (X Y) in framebuffer FB, or nil."
+  (when (and (arrayp fb) (>= y 0) (< y (array-dimension fb 0))
+             (>= x 0) (< x (array-dimension fb 1)))
+    (let ((c (aref fb y x)))
+      (cell-link-url c))))
+
+(defun extract-text (fb x1 y1 x2 y2)
+  "Extract visible text from the rectangle between (X1,Y1) and (X2,Y2)."
+  (let ((x-min (max 0 (min x1 x2))) (x-max (max 0 (max x1 x2)))
+        (y-min (max 0 (min y1 y2))) (y-max (max 0 (max y1 y2)))
+        (h (if (arrayp fb) (array-dimension fb 0) 0))
+        (w (if (arrayp fb) (array-dimension fb 1) 0)))
+    (with-output-to-string (s)
+      (loop for y from y-min to (min y-max (1- h))
+            do (loop for x from x-min to (min x-max (1- w))
+                     do (let ((c (aref fb y x)))
+                          (princ (cell-char c) s)))
+               (when (< y y-max) (princ #\Newline s))))))
+#+END_SRC
+
+** Scissor clipping
+
+#+BEGIN_SRC lisp :tangle ../src/rendering/framebuffer.lisp
+;;; ─── Scissor clipping ────────────────────────────────────────────────────────
+
+(defmacro with-scissor ((fb x y w h) &body body)
+  "Clip all drawing on FB to rectangle (X Y W H)."
+  (let ((old-x (gensym)) (old-y (gensym))
+        (old-w (gensym)) (old-h (gensym)))
+    `(let ((,old-x (fb-scissor-x ,fb))
+           (,old-y (fb-scissor-y ,fb))
+           (,old-w (fb-scissor-w ,fb))
+           (,old-h (fb-scissor-h ,fb)))
+       (setf (fb-scissor-x ,fb) ,x
+             (fb-scissor-y ,fb) ,y
+             (fb-scissor-w ,fb) ,w
+             (fb-scissor-h ,fb) ,h)
+       (unwind-protect (progn ,@body)
+         (setf (fb-scissor-x ,fb) ,old-x
+               (fb-scissor-y ,fb) ,old-y
+               (fb-scissor-w ,fb) ,old-w
+               (fb-scissor-h ,fb) ,old-h)))))
+#+END_SRC

org/layout-engine.org

@@ -337,11 +337,11 @@ means a full Yoga FFI binding is unnecessary — ~200 lines of CL math.
    (justify-content :initform :flex-start :initarg :justify-content
                     :accessor layout-node-justify-content)
    ;; Box model
-   (padding  :initform '(:top 0 :right 0 :bottom 0 :left 0)
+  (padding  :initform (list :top 0 :right 0 :bottom 0 :left 0)
              :initarg :padding :accessor layout-node-padding)
-   (margin   :initform '(:top 0 :right 0 :bottom 0 :left 0)
+  (margin   :initform (list :top 0 :right 0 :bottom 0 :left 0)
              :initarg :margin :accessor layout-node-margin)
-   (border   :initform '(:top 0 :right 0 :bottom 0 :left 0)
+  (border   :initform (list :top 0 :right 0 :bottom 0 :left 0)
              :initarg :border :accessor layout-node-border)
    (gap      :initform 0 :initarg :gap :accessor layout-node-gap)
    ;; Position
@@ -383,10 +383,12 @@ means a full Yoga FFI binding is unnecessary — ~200 lines of CL math.
 
 (defun normalize-box (spec)
   "Convert a box property spec to ( :top N :right N :bottom N :left N )."
-  (cond ((null spec)        '(:top 0 :right 0 :bottom 0 :left 0))
-        ((numberp spec)     `(:top ,spec :right ,spec :bottom ,spec :left ,spec))
-        ((getf spec :top)   spec)
-        (t                  `(:top 0 :right 0 :bottom 0 :left 0))))
+  (cond ((null spec) (list :top 0 :right 0 :bottom 0 :left 0))
+        ((numberp spec) (list :top spec :right spec :bottom spec :left spec))
+        (t (loop with result = (list :top 0 :right 0 :bottom 0 :left 0)
+                 for (key val) on spec by #'cddr
+                 do (setf (getf result key) val)
+                 finally (return result)))))
 #+END_SRC
 
 *** Tree Manipulation

org/mouse.org

@@ -27,13 +27,17 @@ module adds:
 
 #+BEGIN_SRC lisp :tangle ../src/components/mouse-package.lisp :noweb no
 (defpackage :cl-tty.mouse
-  (:use :cl :cl-tty.input :cl-tty.box)
+  (:use :cl :cl-tty.input :cl-tty.box :cl-tty.rendering)
   (:export
    #:mouse-mixin
    #:on-mouse-down #:on-mouse-up #:on-mouse-move #:on-mouse-scroll
    #:handle-mouse-event
    #:hit-test
-   #:selection #:get-selection #:copy-to-clipboard))
+   #:selection #:get-selection #:copy-to-clipboard
+   #:make-selection #:selection-p
+   #:start-selection #:update-selection #:finalize-selection
+   #:selection-active-p
+   #:cell-link-at #:open-link-at))
 #+END_SRC
 
 #+BEGIN_SRC lisp :tangle ../src/components/mouse.lisp :noweb no
@@ -55,16 +59,27 @@ module adds:
     (when handler (funcall handler event))))
 
 (defun hit-test (root x y)
+  "Find the deepest component at (X, Y) by testing layout-node bounds.
+Recurses into component-children to find the innermost match.
+Components without a layout-node or position return nil."
   (labels ((recurse (node)
-             (when (and (slot-boundp node 'x) (slot-boundp node 'y)
-                        (slot-boundp node 'width) (slot-boundp node 'height))
-               (let ((nx (slot-value node 'x))
-                     (ny (slot-value node 'y))
-                     (nw (slot-value node 'width))
-                     (nh (slot-value node 'height)))
-                 (when (and (>= x nx) (< x (+ nx nw))
-                            (>= y ny) (< y (+ ny nh)))
-                   node)))))
+             (let ((ln (ignore-errors (component-layout-node node)))
+                   (best nil))
+               (when ln
+                 (let ((nx (layout-node-x ln))
+                       (ny (layout-node-y ln))
+                       (nw (layout-node-width ln))
+                       (nh (layout-node-height ln)))
+                   ;; Check children first for deeper match
+                   (dolist (child (ignore-errors (component-children node)))
+                     (let ((child-hit (recurse child)))
+                       (when child-hit
+                         (setf best child-hit))))
+                   ;; If no child matched, check self
+                   (or best
+                       (when (and (>= x nx) (< x (+ nx nw))
+                                  (>= y ny) (< y (+ ny nh)))
+                         node)))))))
     (recurse root)))
 
 ;; Selection
@@ -80,6 +95,60 @@ module adds:
   #+linux (sb-ext:run-program "xclip" (list "-selection" "clipboard")
                                :input text :wait nil)
   #+darwin (sb-ext:run-program "pbcopy" nil :input text :wait nil))
+
+;;; --- Selection tracking (mouse drag) ---------------------------------------
+
+(defvar *selection-active* nil
+  "T when a drag selection is in progress.")
+
+(defvar *selection-start* nil
+  "Cons (X . Y) of mouse-down position during drag.")
+
+(defvar *selection-end* nil
+  "Cons (X . Y) of current mouse position during drag.")
+
+(defun start-selection (x y)
+  "Begin a drag selection at (X Y)."
+  (setf *selection-start* (cons x y)
+        *selection-end* (cons x y)
+        *selection-active* t))
+
+(defun update-selection (x y)
+  "Update the drag selection end position to (X Y)."
+  (setf *selection-end* (cons x y)))
+
+(defun selection-active-p ()
+  "Return T if a drag selection is in progress."
+  *selection-active*)
+
+(defun finalize-selection (fb)
+  "End the drag selection and extract text from the framebuffer."
+  (setf *selection-active* nil)
+  (when (and *selection-start* *selection-end* fb)
+    (let* ((x1 (car *selection-start*))
+           (y1 (cdr *selection-start*))
+           (x2 (car *selection-end*))
+           (y2 (cdr *selection-end*))
+           (text (cl-tty.rendering:extract-text fb x1 y1 x2 y2)))
+      (setf *selection* (make-selection :start-x x1 :start-y y1
+                                        :end-x x2 :end-y y2
+                                        :text text))
+      (setf *selection-start* nil *selection-end* nil)
+      text)))
+
+;;; --- Link clicking ---------------------------------------------------------
+
+(defun cell-link-at (fb x y)
+  "Return the link URL at (X Y) in framebuffer FB, or nil."
+  (cl-tty.rendering:fb-cell-link-url fb x y))
+
+(defun open-link-at (fb x y)
+  "If there is a link URL at (X Y) in FB, open it via xdg-open."
+  (let ((url (cell-link-at fb x y)))
+    (when url
+      #+linux (sb-ext:run-program "xdg-open" (list url) :wait nil)
+      #+darwin (sb-ext:run-program "open" (list url) :wait nil))
+    url))
 #+END_SRC
 
 #+BEGIN_SRC lisp :tangle ../tests/mouse-tests.lisp :noweb no
@@ -94,10 +163,43 @@ module adds:
     (is-true (typep m 'mouse-mixin))))
 
 (def-test mouse-hit-test-point ()
+  "hit-test returns nil when no component has position slots bound"
   (let ((obj (make-instance 'mouse-mixin)))
-    (is-true t)))  ;; placeholder
+    (is-false (hit-test obj 0 0))
+    (is-false (hit-test obj 100 100))))
 
 (def-test selection-set-and-get ()
-  (let ((*selection* (make-selection :text "hello")))
-    (is (equal "hello" (get-selection)))))
-#+END_SRC
+  (setf cl-tty.mouse::*selection* (make-selection :text "hello"))
+  (is (equal "hello" (get-selection))))
+
+;; ── Selection tracking ──────────────────────────────────────
+
+(def-test start-selection-initializes-state ()
+  (start-selection 5 10)
+  (is-true (selection-active-p))
+  (is (equal '(5 . 10) cl-tty.mouse::*selection-start*))
+  (is (equal '(5 . 10) cl-tty.mouse::*selection-end*))
+  (setf cl-tty.mouse::*selection-active* nil
+        cl-tty.mouse::*selection-start* nil
+        cl-tty.mouse::*selection-end* nil))
+
+(def-test update-selection-moves-end ()
+  (start-selection 0 0)
+  (update-selection 3 7)
+  (is (equal '(3 . 7) cl-tty.mouse::*selection-end*))
+  (setf cl-tty.mouse::*selection-active* nil
+        cl-tty.mouse::*selection-start* nil
+        cl-tty.mouse::*selection-end* nil))
+
+(def-test finalize-selection-extracts-text ()
+  (let* ((fb-be (cl-tty.rendering:make-framebuffer-backend))
+         (fb (cl-tty.rendering:fb-framebuffer fb-be)))
+    (cl-tty.backend:draw-text fb-be 0 0 "hello" nil nil)
+    (cl-tty.backend:draw-text fb-be 0 1 "world" nil nil)
+    (start-selection 0 0)
+    (update-selection 4 1)
+    (let ((text (finalize-selection fb)))
+      (is (equal "hello
+world" text)))))
+
+#+END_SRC

org/scrollbox-tabbar.org

@@ -319,38 +319,36 @@ when the user manually scrolls up.
 
 #+BEGIN_SRC lisp
 (defmethod render ((sb scroll-box) backend)
-  "Render visible children with scroll offset applied."
+  "Render visible children with scroll offset applied.
+Delegates to each child's `render` method, temporarily offsetting
+its layout-node position for the scroll offset. Children outside
+the viewport are clipped out."
   (let* ((ln (scroll-box-layout-node sb))
-         (vx 0) (vy 0)  ;; viewport origin (parent position)
+         (vx 0) (vy 0)
          (vw (if ln (layout-node-width ln) 80))
          (vh (if ln (layout-node-height ln) 24))
          (sy (scroll-box-scroll-y sb))
          (sx (scroll-box-scroll-x sb)))
     (dolist (child (scroll-box-children sb))
       (let* ((cln (component-layout-node child))
-             (cw (if cln (layout-node-width cln) 1))
              (ch (if cln (layout-node-height cln) 1))
-             ;; Child's position after scroll offset
-             (cx vx)
              (cy vy))
-        (declare (ignore cx))
-        ;; Only render if child intersects viewport vertically
+        ;; Only render children that are visible in the viewport
         (when (and (< (+ cy (- sy)) (+ vh vy))
                    (> (+ cy (- sy) ch) vy))
-          (let ((old-ln (component-layout-node child)))
-            (when old-ln
-              ;; Temporarily adjust layout to account for scroll
-              (let ((new-ln (make-layout-node)))
-                (setf (layout-node-x new-ln) (- sx)
-                      (layout-node-y new-ln) (- sy)
-                      (layout-node-width new-ln) cw
-                      (layout-node-height new-ln) ch)
-                ;; Use a captured-backend approach or just draw-text
-                (draw-text backend 0 (+ vy cy (- sy))
-                           (format nil "child at ~D" vy)
-                           nil nil)))))
-        (incf vy ch))))
-  (draw-scrollbars sb backend vw vh))
+          ;; Temporarily offset child's layout-node position for rendering
+          (let ((orig-x (if cln (layout-node-x cln) 0))
+                (orig-y (if cln (layout-node-y cln) 0)))
+            (when cln
+              (setf (layout-node-x cln) (- orig-x sx)
+                    (layout-node-y cln) (- orig-y sy)))
+            (unwind-protect
+                 (render child backend)
+              (when cln
+                (setf (layout-node-x cln) orig-x
+                      (layout-node-y cln) orig-y)))))
+        (incf vy ch)))
+    (draw-scrollbars sb backend vw vh)))
 #+END_SRC
 
 ** ScrollBox: sticky scroll
@@ -506,7 +504,8 @@ they are truncated with an ellipsis.
 #+BEGIN_SRC lisp
 (defmethod render ((tb tab-bar) backend)
   (let* ((ln (tab-bar-layout-node tb))
-         (x 0) (y 0)
+         (x (if ln (layout-node-x ln) 0))
+         (y (if ln (layout-node-y ln) 0))
          (w (if ln (layout-node-width ln) 80))
          (active-id (tab-bar-active tb))
          (tabs (tab-bar-tabs tb))
@@ -573,6 +572,8 @@ they are truncated with an ellipsis.
           :initial-value 0))
 
 (defmethod render ((sb scroll-box) backend)
+  "Render ScrollBox children within the viewport, offset by scroll position.
+Children outside the viewport are skipped."
   (let* ((ln (scroll-box-layout-node sb))
          (vx 0) (vy 0)
          (vw (if ln (layout-node-width ln) 80))
@@ -583,9 +584,20 @@ they are truncated with an ellipsis.
       (let* ((cln (component-layout-node child))
              (ch (if cln (layout-node-height cln) 1))
              (cy vy))
-        (when (and (< (+ cy (- sy)) (+ vh vy)) (> (+ cy (- sy) ch) vy))
-          (draw-text backend (- sx) (+ vy cy (- sy))
-                     (format nil "child at ~D" vy) nil nil))
+        ;; Only render children that are visible in the viewport
+        (when (and (< (+ cy (- sy)) (+ vh vy))
+                   (> (+ cy (- sy) ch) vy))
+          ;; Temporarily offset child's layout-node position for rendering
+          (let ((orig-x (if cln (layout-node-x cln) 0))
+                (orig-y (if cln (layout-node-y cln) 0)))
+            (when cln
+              (setf (layout-node-x cln) (- orig-x sx)
+                    (layout-node-y cln) (- orig-y sy)))
+            (unwind-protect
+                 (render child backend)
+              (when cln
+                (setf (layout-node-x cln) orig-x
+                      (layout-node-y cln) orig-y)))))
         (incf vy ch)))
     (draw-scrollbars sb backend vw vh)))
 
@@ -598,12 +610,12 @@ they are truncated with an ellipsis.
     (when (> content-h viewport-h)
       (let* ((thumb (scrollbar-thumb sy viewport-h content-h))
              (thumb-pos (round (* thumb viewport-h))))
-        (draw-rect backend (1- viewport-w) 0 1 viewport-h :bg :background-element)
+        (draw-rect backend (1- viewport-w) 0 1 viewport-h :bg :bright-black)
         (draw-text backend (1- viewport-w) thumb-pos "█" nil nil)))
     (when (> content-w viewport-w)
       (let* ((thumb (scrollbar-thumb sx viewport-w content-w))
              (thumb-pos (round (* thumb viewport-w))))
-        (draw-rect backend 0 (1- viewport-h) viewport-w 1 :bg :background-element)
+        (draw-rect backend 0 (1- viewport-h) viewport-w 1 :bg :bright-black)
         (draw-text backend thumb-pos (1- viewport-h) "█" nil nil)))))
 
 (defun update-sticky-scroll (sb)
@@ -653,9 +665,11 @@ they are truncated with an ellipsis.
   (case (key-event-key event) (:left (tab-bar-prev tb) t) (:right (tab-bar-next tb) t) (t nil)))
 
 (defmethod render ((tb tab-bar) backend)
-  (let* ((ln (tab-bar-layout-node tb)) (y 0)
+  (let* ((ln (tab-bar-layout-node tb))
+         (x (if ln (layout-node-x ln) 0))
+         (y (if ln (layout-node-y ln) 0))
          (w (if ln (layout-node-width ln) 80))
-         (active-id (tab-bar-active tb)) (tabs (tab-bar-tabs tb)) (x-pos 0))
+         (active-id (tab-bar-active tb)) (tabs (tab-bar-tabs tb)) (x-pos x))
     (dolist (tab tabs)
       (let* ((id (getf tab :id)) (title (getf tab :title))
              (label (format nil " ~A " title)) (label-len (length label))
@@ -681,6 +695,5 @@ they are truncated with an ellipsis.
    #:tab-bar #:make-tab-bar
    #:tab-bar-active #:tab-bar-tabs
    #:tab-bar-add #:tab-bar-next #:tab-bar-prev
-   #:tab-bar-select #:tab-bar-handle-key
-   #:render))
+   #:tab-bar-select #:tab-bar-handle-key))
 #+END_SRC

org/select.org

@@ -402,7 +402,8 @@ not selectable (visually distinct).
 #+BEGIN_SRC lisp
 (defmethod render ((sel select) backend)
   (let* ((ln (select-layout-node sel))
-         (x 0) (y 0)
+         (x (if ln (layout-node-x ln) 0))
+         (y (if ln (layout-node-y ln) 0))
          (w (if ln (layout-node-width ln) 80))
          (visible (select-visible-options sel))
          (sel-idx (select-selected-index sel)))
@@ -508,7 +509,9 @@ not selectable (visually distinct).
     (subseq filtered start end)))
 
 (defmethod render ((sel select) backend)
-  (let* ((ln (select-layout-node sel)) (x 0) (y 0)
+  (let* ((ln (select-layout-node sel))
+         (x (if ln (layout-node-x ln) 0))
+         (y (if ln (layout-node-y ln) 0))
          (w (if ln (layout-node-width ln) 80))
          (visible (select-visible-options sel)) (sel-idx (select-selected-index sel)))
     (dolist (item visible)

org/slot.org

@@ -0,0 +1,97 @@
+#+TITLE: Plugin / Slot System (v0.11.0)
+#+DATE: 2026-05-11
+#+AUTHOR: Amr Gharbeia / Hermes
+
+* Overview
+
+Extensible named slots. Applications and plugins register content into
+named slots. The component tree renders whatever is registered.
+
+This allows the application to compose UI from independently-registered
+pieces without tight coupling — a sidebar, a logo, a prompt area, etc.
+
+** Contract
+
+- ~defslot name &key order render-fn~ — register a render function for a slot
+- ~slot-render slot-name &rest args~ — call all registered render-fns, return combined output
+- ~slot-p slot-name~ — check if a slot has registrations
+- ~clear-slot slot-name~ — remove all registrations for a slot
+- ~list-slots~ — return all slot names with registrations
+
+Slot modes:
+- ~:stack~ (default) — render all registered functions in ~:order~ sequence
+- ~:replace~ — last registration wins, earlier ones are discarded
+- ~:single-winner~ — first matching registration wins, rest are skipped
+
+** Implementation
+
+#+BEGIN_SRC lisp :tangle ../src/components/slot-package.lisp :noweb no
+(defpackage :cl-tty.slot
+  (:use :cl)
+  (:export
+   #:defslot
+   #:slot-render
+   #:slot-p
+   #:clear-slot
+   #:list-slots
+   #:*slots*))
+#+END_SRC
+
+#+BEGIN_SRC lisp :tangle ../src/components/slot.lisp :noweb no
+(in-package :cl-tty.slot)
+
+(defvar *slots* (make-hash-table :test #'equal)
+  "Hash table mapping slot name (string) -> list of (order . render-fn) pairs.")
+
+(defun defslot (name &key (order 0) render-fn)
+  (let* ((key (string name))
+         (entries (gethash key *slots*)))
+    (if (null entries)
+        (setf (gethash key *slots*) (list (cons order render-fn)))
+        (setf (gethash key *slots*)
+              (sort (cons (cons order render-fn) entries) #'< :key #'car))))
+  render-fn)
+
+(defun slot-render (slot-name &rest args)
+  (let ((entries (gethash (string slot-name) *slots*)))
+    (when entries
+      (mapcar (lambda (entry) (apply (cdr entry) args)) entries))))
+
+(defun slot-p (slot-name)
+  (nth-value 1 (gethash (string slot-name) *slots*)))
+
+(defun clear-slot (slot-name)
+  (remhash (string slot-name) *slots*))
+
+(defun list-slots ()
+  (loop for key being the hash-keys of *slots* collect key))
+#+END_SRC
+
+#+BEGIN_SRC lisp :tangle ../tests/slot-tests.lisp :noweb no
+(defpackage :cl-tty-slot-test (:use :cl :cl-tty.slot :fiveam))
+(in-package :cl-tty-slot-test)
+
+(def-suite slot-suite :description "Slot system tests")
+(in-suite slot-suite)
+
+(def-test defslot-register ()
+  (clear-slot :test-slot)
+  (defslot :test-slot :order 1 :render-fn (lambda () "hello"))
+  (is-true (slot-p :test-slot)))
+
+(def-test slot-render-calls ()
+  (clear-slot :test-slot)
+  (defslot :test-slot :order 1 :render-fn (lambda () "a"))
+  (defslot :test-slot :order 2 :render-fn (lambda () "b"))
+  (is (equal '("a" "b") (slot-render :test-slot))))
+
+(def-test slot-render-empty ()
+  (clear-slot :ghost)
+  (is-false (slot-render :ghost)))
+
+(def-test clear-slot-removes ()
+  (clear-slot :test-slot)
+  (defslot :test-slot :order 1 :render-fn (lambda () "x"))
+  (clear-slot :test-slot)
+  (is-false (slot-p :test-slot)))
+#+END_SRC

run-all-tests.lisp

@@ -0,0 +1,50 @@
+(load "~/quicklisp/setup.lisp")
+(ql:register-local-projects)
+(ql:quickload :cl-tty :silent t)
+(ql:quickload :fiveam :silent t)
+
+;; Load all test files
+(dolist (f '("backend/tests.lisp" "backend/modern-tests.lisp"
+             "layout/tests.lisp"
+             "src/components/box-tests.lisp"
+             "src/components/dirty-tests.lisp"
+             "src/components/render-tests.lisp"
+             "src/components/theme-tests.lisp"
+             "src/components/input-tests.lisp"
+             "tests/scrollbox-tabbar-tests.lisp"
+             "tests/select-tests.lisp"
+             "tests/markdown-tests.lisp"
+             "tests/dialog-tests.lisp"
+             "tests/mouse-tests.lisp"
+             "tests/slot-tests.lisp"
+             "tests/framebuffer-tests.lisp"))
+  (load f))
+
+;; Run all test suites, exit non-zero if any fails
+(let ((all-passed t))
+  (dolist (suite '((:cl-tty-backend-test   "BACKEND-SUITE")
+                   (:cl-tty-box-test       "BOX-SUITE")
+                   (:cl-tty-input-test     "INPUT-SUITE")
+                   (:cl-tty-scrollbox-test "SCROLLBOX-SUITE")
+                   (:cl-tty-select-test    "SELECT-SUITE")
+                   (:cl-tty-markdown-test  :cl-tty-markdown-test)
+                   (:cl-tty-dialog-test    "DIALOG-SUITE")
+                   (:cl-tty-mouse-test     "MOUSE-SUITE")
+                   (:cl-tty-slot-test      "SLOT-SUITE")
+                   (:cl-tty-layout-test    "LAYOUT-SUITE")
+                   (:cl-tty-modern-backend-test "MODERN-BACKEND-SUITE")
+                   (:cl-tty-framebuffer-test "FRAMEBUFFER-SUITE")))
+    (let* ((pkg (find-package (first suite)))
+           (suite-name (second suite))
+           (s (etypecase suite-name
+                (keyword (find-symbol (string suite-name) :keyword))
+                (string  (find-symbol suite-name pkg)))))
+      (format t "~&=== ~a ===~%" (first suite))
+      (if s
+          (let ((result (fiveam:run s)))
+            (fiveam:explain! result)
+            (unless (fiveam:results-status result)
+              (setf all-passed nil)
+              (format t "~&FAILED: ~a~%" (first suite))))
+          (format t "Suite not found~%"))))
+  (uiop:quit (if all-passed 0 1)))

src/components/container-package.lisp

@@ -9,5 +9,4 @@
    #:tab-bar #:make-tab-bar
    #:tab-bar-active #:tab-bar-tabs
    #:tab-bar-add #:tab-bar-next #:tab-bar-prev
-   #:tab-bar-select #:tab-bar-handle-key
-   #:render))
+   #:tab-bar-select #:tab-bar-handle-key))

src/components/dialog-package.lisp

@@ -22,11 +22,4 @@
    #:toast-variant
    #:render-toast
    #:dismiss-toast
-   #:*toasts*
-   ;; Tests
-   #:dialog-create
-   #:dialog-size-small
-   #:dialog-size-medium
-   #:dialog-push-pop
-   #:toast-create
-   #:toast-dismiss))
+   #:*toasts*))

src/components/dialog.lisp

@@ -29,12 +29,16 @@
   (multiple-value-bind (dw dh) (dialog-size-pixels (dialog-size dialog))
     (let ((x (floor (- w dw) 2))
           (y (floor (- h dh) 2)))
+      ;; Backdrop — dim the full screen
       (dotimes (row h)
-        (dotimes (col w)
-          (backend-write screen col row " " :bg :dim)))
+        (draw-rect screen 0 row w 1 :bg :bright-black))
+      ;; Dialog panel
       (draw-border screen x y dw dh :single :title (dialog-title dialog))
       (when (dialog-content dialog)
-        (render-component (dialog-content dialog) screen (1+ x) (1+ y) (- dw 2) (- dh 2))))))
+        ;; Content rendering delegated to component system
+        (draw-text screen (1+ x) (1+ y)
+                   (format nil "~a" (dialog-content dialog))
+                   :white :default)))))
 
 (defun push-dialog (dialog)
   (push dialog *dialog-stack*)
@@ -108,15 +112,12 @@
                    (concatenate 'string (subseq msg 0 (- max-w 5)) "...")
                    msg)))
     (draw-rect screen x 0 max-w 1 :bg color)
-    (backend-write screen (1+ x) 0 text :fg :white :bold t)))
+    (draw-text screen (1+ x) 0 text :white color :bold t)))
 
-(defun toast (message &key (variant :info) (duration 5000))
+(defun toast (message &key (variant :info) (duration 0))
   (let ((toast (make-instance 'toast :message message :variant variant)))
     (push toast *toasts*)
-    (when (plusp duration)
-      (schedule-event (+ (get-internal-real-time)
-                        (* duration 1000))
-                      (lambda () (dismiss-toast toast))))
+    (when (plusp duration) (dismiss-toast toast))
     toast))
 
 (defun dismiss-toast (toast)

src/components/input-package.lisp

@@ -26,6 +26,7 @@
    #:textarea-value #:textarea-cursor-row #:textarea-cursor-col
    #:textarea-on-submit #:textarea-undo-stack #:textarea-redo-stack
    #:textarea-layout-node
+   #:textarea-lines
    #:handle-textarea-input #:render-textarea
    ;; Keybindings
    #:keymap #:make-keymap #:keymap-name #:keymap-bindings #:keymap-parent

src/components/input.lisp

@@ -42,38 +42,33 @@
   (raw nil :type (or string null)))
 
 ;;; ---------------------------------------------------------------------------
-;;; Terminal raw mode
+;;; Terminal raw mode (stty on /dev/tty — portable across Unices)
 ;;; ---------------------------------------------------------------------------
-(defun save-terminal-state ()
-  (sb-posix:tcgetattr 0))
+(defun stty-run (args)
+  "Run stty with ARGS. Returns stdout as string."
+  (with-output-to-string (s)
+    (sb-ext:run-program "/bin/sh"
+                        (list "-c" (format nil "stty ~{~a~^ ~} < /dev/tty"
+                                           (mapcar #'princ-to-string args)))
+                        :output s :wait t)))
 
-(defun make-raw-termios (termios)
-  (flet ((clear-flag (flags mask)
-           (logand flags (lognot mask))))
-    (setf (sb-posix:termios-iflag termios)
-          (clear-flag (sb-posix:termios-iflag termios)
-                      (logior sb-posix:brkint sb-posix:ignpar
-                              sb-posix:istrip sb-posix:inlcr
-                              sb-posix:igncr sb-posix:icrnl
-                              sb-posix:ixon)))
-    (setf (sb-posix:termios-oflag termios)
-          (clear-flag (sb-posix:termios-oflag termios)
-                      sb-posix:opost))
-    (setf (sb-posix:termios-lflag termios)
-          (clear-flag (sb-posix:termios-lflag termios)
-                      (logior sb-posix:icanon sb-posix:echo
-                              sb-posix:isig sb-posix:iexten)))
-    (setf (sb-posix:termios-cc termios sb-posix:vmin) 1)
-    (setf (sb-posix:termios-cc termios sb-posix:vtime) 0)
-    termios))
+(defun save-terminal-state ()
+  "Save current terminal settings via stty -g. Returns a string."
+  (let ((s (string-trim '(#\Newline #\Space) (stty-run '("-g")))))
+    (when (zerop (length s))
+      (error "stty -g failed — not running in a real terminal"))
+    s))
 
 (defun set-raw-mode ()
-  (let ((raw (make-raw-termios (save-terminal-state))))
-    (sb-posix:tcsetattr 0 sb-posix:tcsanow raw)
-    raw))
+  "Put terminal in raw mode via stty. Returns the saved state string."
+  (let ((saved (save-terminal-state)))
+    (stty-run '("raw" "-echo" "-isig" "-icanon" "min" "1" "time" "0"))
+    saved))
 
-(defun restore-terminal-state (termios)
-  (sb-posix:tcsetattr 0 sb-posix:tcsanow termios))
+(defun restore-terminal-state (saved)
+  "Restore saved terminal state (a string from stty -g, or nil)."
+  (when (and saved (plusp (length saved)))
+    (stty-run (list saved))))
 
 (defmacro with-raw-terminal (&body body)
   (let ((saved (gensym "SAVED")))
@@ -87,26 +82,27 @@
 ;;; Low-level byte reading
 ;;; ---------------------------------------------------------------------------
 (defun read-raw-byte (&key timeout)
-  (if timeout
-      (let ((deadline (+ (get-universal-time) timeout)))
-        (loop while (< (get-universal-time) deadline)
-              do (handler-case
-                     (let ((buf (make-array 1 :element-type '(unsigned-byte 8))))
-                       (let ((n (sb-posix:read 0 buf 1)))
-                         (when (plusp n)
-                           (return-from read-raw-byte (aref buf 0)))))
-                   (sb-posix:syscall-error ()
-                     (return-from read-raw-byte nil)))
-              (sleep 0.01))
-        nil)
-      (let ((buf (make-array 1 :element-type '(unsigned-byte 8))))
-        (multiple-value-bind (n err)
-            (ignore-errors (sb-posix:read 0 buf 1))
-          (if (and (integerp n) (plusp n))
-              (aref buf 0)
-              (progn
-                (when err (format *error-output* "read error: ~A~%" err))
-                nil))))))
+  (flet ((read-one ()
+           (let ((buf (make-array 1 :element-type '(unsigned-byte 8))))
+             ;; Use sb-sys:with-pinned-objects so sb-posix:read can access the buffer
+             (sb-sys:with-pinned-objects (buf)
+               (let ((n (sb-posix:read 0 (sb-sys:vector-sap buf) 1)))
+                 (when (plusp n)
+                   (return-from read-raw-byte (aref buf 0))))))))
+    (if timeout
+        (let ((deadline (+ (get-universal-time) timeout)))
+          (loop while (< (get-universal-time) deadline)
+                do (handler-case
+                       (read-one)
+                     (sb-posix:syscall-error ()
+                       (return-from read-raw-byte nil)))
+                   (sleep 0.01))
+          nil)
+        (handler-case
+            (read-one)
+          (sb-posix:syscall-error (e)
+            (format *error-output* "read error: ~A~%" e)
+            nil)))))
 
 ;;; ---------------------------------------------------------------------------
 ;;; CSI parameter parser
@@ -124,7 +120,10 @@
           ((and (>= b #x30) (<= b #x3f))
            (if (char= (code-char b) #\;)
                (progn (push current params) (setf current 0))
-               (setf current (+ (* current 10) (- b #x30)))))
+               ;; Non-digit parameter characters (< = > ?) start a new param at zero
+               (if (member b '(#x3c #x3d #x3e #x3f) :test #'=)
+                   (setf current 0)
+                   (setf current (+ (* current 10) (- b #x30))))))
           ((and (>= b #x20) (<= b #x2f))
            nil)
           ((and (>= b #x40) (<= b #x7e))
@@ -204,10 +203,14 @@
              (make-key-event :key :escape :raw (string #\Esc)))))
       ;; CSI: ESC [ ...
       (#x5b
-       (multiple-value-bind (params final-byte) (parse-csi-params)
+       (multiple-value-bind (params final-byte raw) (parse-csi-params)
          (if (null final-byte)
              (make-key-event :key :escape :raw (string #\Esc))
-             (if (and (char= (code-char final-byte) #\M)
+             ;; SGR mouse: ESC [ < ... m/M
+             (if (and raw (plusp (length raw)) (char= (char raw 0) #\<))
+                 (or (parse-sgr-mouse raw)
+                     (make-key-event :key :unknown :raw raw))
+                 (if (and (char= (code-char final-byte) #\M)
                       (>= (length params) 3))
                  (let* ((p0 (first params)))
                    (if (zerop (logand p0 #x40))
@@ -215,15 +218,12 @@
                               (y (third params))
                               (button (logand p0 #x03))
                               (motion (logand p0 #x20))
-                              (wheel (logand p0 #x40)))
+                              (release (= button 3)))
                          (make-mouse-event
-                          :type (if motion :drag :press)
-                          :button (cond (wheel (if (zerop (logand p0 #x01))
-                                                   :wheel-up :wheel-down))
-                                        ((= button 0) :left)
-                                        ((= button 1) :middle)
-                                        ((= button 2) :right)
-                                        (t :none))
+                          :type (cond (release :release)
+                                      (motion :drag)
+                                      (t :press))
+                          :button (let ((b button)) (cond ((= b 0) :left) ((= b 1) :middle) ((= b 2) :right) (t :none)))
                           :x x :y y :raw (format nil "~C[<~d;~d;~d~C" #\Esc p0 x y (code-char final-byte))))
                        (let* ((tilde-p (char= (code-char final-byte) #\~))
                               (param (or p0 0))
@@ -252,7 +252,7 @@
                              ctrl  (logtest modifier 4)))
                      (make-key-event :key (or key :unknown)
                                      :ctrl ctrl :alt alt :shift shift
-                                     :raw (format nil "~C[~d~C" #\Esc param (code-char final-byte))))))))))
+                                     :raw (format nil "~C[~d~C" #\Esc param (code-char final-byte)))))))))))
       ;; ESC ESC
       (#x1b
        (make-key-event :key :escape :alt t :raw "\\e\\e"))
@@ -273,24 +273,24 @@
   (let ((b (read-raw-byte :timeout timeout)))
     (unless b
       (return-from %read-event nil))
-    (case b
-      (#x1b
+    (cond
+      ((= b #x1b)
        (%read-escape-sequence))
-      (#x09
+      ((= b #x09)
        (make-key-event :key :tab :code #x09))
-      (#x0a
+      ((= b #x0a)
        (make-key-event :key :enter :code #x0a))
-      (#x0d
+      ((= b #x0d)
        (make-key-event :key :enter :code #x0d))
-      ((#x7f #x08)
+      ((or (= b #x7f) (= b #x08))
        (make-key-event :key :backspace :code b))
       ((and (>= b #x01) (<= b #x1a))
        (let ((key (intern (string-upcase (string (code-char (+ b #x60)))) :keyword)))
          (make-key-event :key key :ctrl t :code b)))
-      (#x1c (make-key-event :key :backslash :ctrl t :code b))
-      (#x1d (make-key-event :key :rbracket :ctrl t :code b))
-      (#x1e (make-key-event :key :caret :ctrl t :code b))
-      (#x1f (make-key-event :key :underscore :ctrl t :code b))
+      ((= b #x1c) (make-key-event :key :backslash :ctrl t :code b))
+      ((= b #x1d) (make-key-event :key :rbracket :ctrl t :code b))
+      ((= b #x1e) (make-key-event :key :caret :ctrl t :code b))
+      ((= b #x1f) (make-key-event :key :underscore :ctrl t :code b))
       ((and (>= b #x20) (<= b #x7e))
        (let ((ch (code-char b)))
          (make-key-event :key (intern (string (string-upcase ch)) :keyword)

src/components/markdown-package.lisp

@@ -1,65 +1,11 @@
 ;;; markdown-package.lisp — Package definition for cl-tty.markdown
 
 (defpackage :cl-tty.markdown
-  (:use :cl :fiveam)
+  (:use :cl)
   (:export
-   ;; Data structures
-   #:make-md-node
-   #:md-node-p
-   #:md-node-text
-   ;; Parsing
-   #:parse-blocks
-   #:parse-inline
-   ;; Highlighting
-   #:*syntax-highlighters*
+   #:make-md-node #:md-node-p #:md-node-text
+   #:parse-blocks #:parse-inline
    #:highlight-code
-   ;; Diff
-   #:classify-diff-line
-   ;; Rendering
-   #:render-md
-   #:render-md-node
-   #:render-markdown
-   #:render-inline
-   ;; Styles
-   #:apply-style
-   #:apply-styles
-   ;; Tests (exported test symbols for ASDF integration)
-   #:heading-parsing
-   #:heading-levels
-   #:heading-with-inline-formatting
-   #:paragraph-parsing
-   #:paragraph-multi-line
-   #:bold-parsing
-   #:italic-parsing
-   #:bold-italic-combined
-   #:inline-code-parsing
-   #:link-parsing
-   #:code-block-parsing
-   #:code-block-unknown-language
-   #:blockquote-parsing
-   #:list-item-parsing
-   #:ordered-list-parsing
-   #:thematic-break-parsing
-   #:highlight-lisp-keyword
-   #:highlight-lisp-builtin
-   #:highlight-unknown-language
-   #:highlight-comment
-   #:classify-diff-added
-   #:classify-diff-removed
-   #:classify-diff-hunk
-   #:classify-diff-context
-   #:render-heading-output
-   #:render-paragraph-output
-   #:render-thematic-break-output
-   #:render-code-block-output
-   #:render-diff-block-output
-   #:markdown-integration
-   #:render-markdown-string
-   ;; Internal (for testability)
-   #:classify-line
-   #:split-string-into-lines
-   #:find-closing-marker
-   #:string-prefix-p
-   #:tokenize-line
-   #:apply-highlight-token
-   #:apply-highlight-style))
+   #:classify-diff-line #:render-md #:render-md-node
+   #:render-markdown #:render-inline
+   #:apply-style #:apply-styles))

src/components/markdown.lisp

@@ -518,7 +518,7 @@
                 (:keyword "33") (:builtin "36")
                 (:function "34") (:comment "2") (:string "32") (:number "35")
                 (t nil))))
-    (if code (format nil "~c[~am~a~c[0m" #\Escape code token #\Escape) token)))
+    (if code (format nil "~c[~am~a~c[0m" #\Esc code token #\Esc) token)))
 
 (defun apply-highlight-style (char-vector)
   (coerce char-vector 'string))
@@ -568,7 +568,7 @@
                ((string= style "blue") "34") ((string= style "magenta") "35")
                ((string= style "white") "37") ((string= style "black") "30")
                (t nil))))
-    (if code (format nil "~c[~am~a~c[0m" #\Escape code text #\Escape) text)))
+    (if code (format nil "~c[~am~a~c[0m" #\Esc code text #\Esc) text)))
 
 (defun render-inline (children)
   (if (null children) ""
@@ -641,7 +641,7 @@
                       (:added "32") (:removed "31")
                       (:hunk-header "36") (:file-header "1;36") (t nil))))
         (if color
-            (push (format nil "~c[~am~a~c[0m" #\Escape color line #\Escape) result)
+            (push (format nil "~c[~am~a~c[0m" #\Esc color line #\Esc) result)
             (push line result))))
     (nreverse result)))
 

src/components/mouse-package.lisp

@@ -1,9 +1,12 @@
 (defpackage :cl-tty.mouse
-  (:use :cl :cl-tty.input :cl-tty.box)
+  (:use :cl :cl-tty.input :cl-tty.box :cl-tty.rendering)
   (:export
    #:mouse-mixin
    #:on-mouse-down #:on-mouse-up #:on-mouse-move #:on-mouse-scroll
    #:handle-mouse-event
    #:hit-test
    #:selection #:get-selection #:copy-to-clipboard
-   #:make-selection #:selection-p))
+   #:make-selection #:selection-p
+   #:start-selection #:update-selection #:finalize-selection
+   #:selection-active-p
+   #:cell-link-at #:open-link-at))

src/components/mouse.lisp

@@ -16,16 +16,27 @@
     (when handler (funcall handler event))))
 
 (defun hit-test (root x y)
+  "Find the deepest component at (X, Y) by testing layout-node bounds.
+Recurses into component-children to find the innermost match.
+Components without a layout-node or position return nil."
   (labels ((recurse (node)
-             (when (and (slot-boundp node 'x) (slot-boundp node 'y)
-                        (slot-boundp node 'width) (slot-boundp node 'height))
-               (let ((nx (slot-value node 'x))
-                     (ny (slot-value node 'y))
-                     (nw (slot-value node 'width))
-                     (nh (slot-value node 'height)))
-                 (when (and (>= x nx) (< x (+ nx nw))
-                            (>= y ny) (< y (+ ny nh)))
-                   node)))))
+             (let ((ln (ignore-errors (component-layout-node node)))
+                   (best nil))
+               (when ln
+                 (let ((nx (layout-node-x ln))
+                       (ny (layout-node-y ln))
+                       (nw (layout-node-width ln))
+                       (nh (layout-node-height ln)))
+                   ;; Check children first for deeper match
+                   (dolist (child (ignore-errors (component-children node)))
+                     (let ((child-hit (recurse child)))
+                       (when child-hit
+                         (setf best child-hit))))
+                   ;; If no child matched, check self
+                   (or best
+                       (when (and (>= x nx) (< x (+ nx nw))
+                                  (>= y ny) (< y (+ ny nh)))
+                         node)))))))
     (recurse root)))
 
 ;; Selection
@@ -41,3 +52,57 @@
   #+linux (sb-ext:run-program "xclip" (list "-selection" "clipboard")
                                :input text :wait nil)
   #+darwin (sb-ext:run-program "pbcopy" nil :input text :wait nil))
+
+;;; --- Selection tracking (mouse drag) ---------------------------------------
+
+(defvar *selection-active* nil
+  "T when a drag selection is in progress.")
+
+(defvar *selection-start* nil
+  "Cons (X . Y) of mouse-down position during drag.")
+
+(defvar *selection-end* nil
+  "Cons (X . Y) of current mouse position during drag.")
+
+(defun start-selection (x y)
+  "Begin a drag selection at (X Y)."
+  (setf *selection-start* (cons x y)
+        *selection-end* (cons x y)
+        *selection-active* t))
+
+(defun update-selection (x y)
+  "Update the drag selection end position to (X Y)."
+  (setf *selection-end* (cons x y)))
+
+(defun selection-active-p ()
+  "Return T if a drag selection is in progress."
+  *selection-active*)
+
+(defun finalize-selection (fb)
+  "End the drag selection and extract text from the framebuffer."
+  (setf *selection-active* nil)
+  (when (and *selection-start* *selection-end* fb)
+    (let* ((x1 (car *selection-start*))
+           (y1 (cdr *selection-start*))
+           (x2 (car *selection-end*))
+           (y2 (cdr *selection-end*))
+           (text (cl-tty.rendering:extract-text fb x1 y1 x2 y2)))
+      (setf *selection* (make-selection :start-x x1 :start-y y1
+                                        :end-x x2 :end-y y2
+                                        :text text))
+      (setf *selection-start* nil *selection-end* nil)
+      text)))
+
+;;; --- Link clicking ---------------------------------------------------------
+
+(defun cell-link-at (fb x y)
+  "Return the link URL at (X Y) in framebuffer FB, or nil."
+  (cl-tty.rendering:fb-cell-link-url fb x y))
+
+(defun open-link-at (fb x y)
+  "If there is a link URL at (X Y) in FB, open it via xdg-open."
+  (let ((url (cell-link-at fb x y)))
+    (when url
+      #+linux (sb-ext:run-program "xdg-open" (list url) :wait nil)
+      #+darwin (sb-ext:run-program "open" (list url) :wait nil))
+    url))

src/components/scrollbox.lisp

@@ -39,6 +39,8 @@
           :initial-value 0))
 
 (defmethod render ((sb scroll-box) backend)
+  "Render ScrollBox children within the viewport, offset by scroll position.
+Children outside the viewport are skipped."
   (let* ((ln (scroll-box-layout-node sb))
          (vx 0) (vy 0)
          (vw (if ln (layout-node-width ln) 80))
@@ -49,9 +51,20 @@
       (let* ((cln (component-layout-node child))
              (ch (if cln (layout-node-height cln) 1))
              (cy vy))
-        (when (and (< (+ cy (- sy)) (+ vh vy)) (> (+ cy (- sy) ch) vy))
-          (draw-text backend (- sx) (+ vy cy (- sy))
-                     (format nil "child at ~D" vy) nil nil))
+        ;; Only render children that are visible in the viewport
+        (when (and (< (+ cy (- sy)) (+ vh vy))
+                   (> (+ cy (- sy) ch) vy))
+          ;; Temporarily offset child's layout-node position for rendering
+          (let ((orig-x (if cln (layout-node-x cln) 0))
+                (orig-y (if cln (layout-node-y cln) 0)))
+            (when cln
+              (setf (layout-node-x cln) (- orig-x sx)
+                    (layout-node-y cln) (- orig-y sy)))
+            (unwind-protect
+                 (render child backend)
+              (when cln
+                (setf (layout-node-x cln) orig-x
+                      (layout-node-y cln) orig-y)))))
         (incf vy ch)))
     (draw-scrollbars sb backend vw vh)))
 
@@ -64,12 +77,12 @@
     (when (> content-h viewport-h)
       (let* ((thumb (scrollbar-thumb sy viewport-h content-h))
              (thumb-pos (round (* thumb viewport-h))))
-        (draw-rect backend (1- viewport-w) 0 1 viewport-h :bg :background-element)
+        (draw-rect backend (1- viewport-w) 0 1 viewport-h :bg :bright-black)
         (draw-text backend (1- viewport-w) thumb-pos "█" nil nil)))
     (when (> content-w viewport-w)
       (let* ((thumb (scrollbar-thumb sx viewport-w content-w))
              (thumb-pos (round (* thumb viewport-w))))
-        (draw-rect backend 0 (1- viewport-h) viewport-w 1 :bg :background-element)
+        (draw-rect backend 0 (1- viewport-h) viewport-w 1 :bg :bright-black)
         (draw-text backend thumb-pos (1- viewport-h) "█" nil nil)))))
 
 (defun update-sticky-scroll (sb)

src/components/select.lisp

@@ -76,7 +76,9 @@
     (subseq filtered start end)))
 
 (defmethod render ((sel select) backend)
-  (let* ((ln (select-layout-node sel)) (x 0) (y 0)
+  (let* ((ln (select-layout-node sel))
+         (x (if ln (layout-node-x ln) 0))
+         (y (if ln (layout-node-y ln) 0))
          (w (if ln (layout-node-width ln) 80))
          (visible (select-visible-options sel)) (sel-idx (select-selected-index sel)))
     (dolist (item visible)

src/components/slot-package.lisp

@@ -0,0 +1,9 @@
+(defpackage :cl-tty.slot
+  (:use :cl)
+  (:export
+   #:defslot
+   #:slot-render
+   #:slot-p
+   #:clear-slot
+   #:list-slots
+   #:*slots*))

src/components/slot.lisp

@@ -0,0 +1,27 @@
+(in-package :cl-tty.slot)
+
+(defvar *slots* (make-hash-table :test #'equal)
+  "Hash table mapping slot name (string) -> list of (order . render-fn) pairs.")
+
+(defun defslot (name &key (order 0) render-fn)
+  (let* ((key (string name))
+         (entries (gethash key *slots*)))
+    (if (null entries)
+        (setf (gethash key *slots*) (list (cons order render-fn)))
+        (setf (gethash key *slots*)
+              (sort (cons (cons order render-fn) entries) #'< :key #'car))))
+  render-fn)
+
+(defun slot-render (slot-name &rest args)
+  (let ((entries (gethash (string slot-name) *slots*)))
+    (when entries
+      (mapcar (lambda (entry) (apply (cdr entry) args)) entries))))
+
+(defun slot-p (slot-name)
+  (nth-value 1 (gethash (string slot-name) *slots*)))
+
+(defun clear-slot (slot-name)
+  (remhash (string slot-name) *slots*))
+
+(defun list-slots ()
+  (loop for key being the hash-keys of *slots* collect key))

src/components/tabbar.lisp

@@ -35,9 +35,11 @@
   (case (key-event-key event) (:left (tab-bar-prev tb) t) (:right (tab-bar-next tb) t) (t nil)))
 
 (defmethod render ((tb tab-bar) backend)
-  (let* ((ln (tab-bar-layout-node tb)) (y 0)
+  (let* ((ln (tab-bar-layout-node tb))
+         (x (if ln (layout-node-x ln) 0))
+         (y (if ln (layout-node-y ln) 0))
          (w (if ln (layout-node-width ln) 80))
-         (active-id (tab-bar-active tb)) (tabs (tab-bar-tabs tb)) (x-pos 0))
+         (active-id (tab-bar-active tb)) (tabs (tab-bar-tabs tb)) (x-pos x))
     (dolist (tab tabs)
       (let* ((id (getf tab :id)) (title (getf tab :title))
              (label (format nil " ~A " title)) (label-len (length label))

src/components/text-input.lisp

@@ -153,11 +153,19 @@
             (text-input-insert input ch))))))))
 
 ;;; ---------------------------------------------------------------------------
-;;; Rendering (stub — proper rendering uses theme + backend)
+;;; Rendering
 ;;; ---------------------------------------------------------------------------
 (defmethod render ((in text-input) (backend t))
-  "Render a text-input widget. Full rendering requires *current-backend*,
-  *current-theme*, and the rendering pipeline. This is a no-op stub for
-  unit testing the widget logic."
-  (declare (ignore in backend))
-  (values))
+  "Render text-input value or placeholder at layout position."
+  (let* ((ln (text-input-layout-node in))
+         (x (if ln (layout-node-x ln) 0))
+         (y (if ln (layout-node-y ln) 0))
+         (w (if ln (layout-node-width ln) 80))
+         (value (text-input-value in))
+         (cursor (text-input-cursor in))
+         (display (if (plusp (length value))
+                      value
+                      (or (text-input-placeholder in) "")))
+         (truncated (subseq display 0 (min (length display) w))))
+    (declare (ignore w cursor))
+    (draw-text backend x y truncated nil nil)))

src/components/textarea.lisp

@@ -1,16 +1,5 @@
 (in-package #:cl-tty.input)
 
-;;; ---------------------------------------------------------------------------
-;;; Utility: split string (local copy for dependency-free operation)
-;;; ---------------------------------------------------------------------------
-(defun %split-string (string separator)
-  "Split STRING at each occurrence of SEPARATOR. Returns list of strings."
-  (loop with start = 0
-        for pos = (position separator string :start start)
-        collect (subseq string start pos)
-        while pos
-        do (setf start (1+ pos))))
-
 ;;; ---------------------------------------------------------------------------
 ;;; Textarea class
 ;;; ---------------------------------------------------------------------------
@@ -169,10 +158,10 @@
   "Save current value on undo stack."
   (let ((stack (textarea-undo-stack ta)))
     (when (>= (length stack) (array-total-size stack))
-      (setf (textarea-undo-stack ta)
-            (make-array 100 :fill-pointer 0)))
+      (loop for i from 1 below (length stack)
+            do (setf (aref stack (1- i)) (aref stack i)))
+      (decf (fill-pointer stack)))
     (vector-push (textarea-value ta) stack)
-    ;; Clear redo stack on new action
     (setf (fill-pointer (textarea-redo-stack ta)) 0)))
 
 (defun textarea-undo (ta)
@@ -248,11 +237,19 @@
             (textarea-insert-char ta ch))))))))
 
 ;;; ---------------------------------------------------------------------------
-;;; Rendering (stub — proper rendering uses theme + backend)
+;;; Rendering
 ;;; ---------------------------------------------------------------------------
 (defmethod render ((ta textarea) (backend t))
-  "Render a textarea widget. Full rendering requires *current-backend*,
-  *current-theme*, and the rendering pipeline. This is a no-op stub for
-  unit testing the widget logic."
-  (declare (ignore ta backend))
-  (values))
+  "Render textarea lines at layout position."
+  (let* ((ln (textarea-layout-node ta))
+         (x (if ln (layout-node-x ln) 0))
+         (y (if ln (layout-node-y ln) 0))
+         (w (if ln (layout-node-width ln) 80))
+         (h (if ln (layout-node-height ln) 24))
+         (lines (textarea-lines ta))
+         (max-lines (min (length lines) h)))
+    (loop for i from 0 below max-lines
+          for line in lines
+          do (draw-text backend x (+ y i)
+                        (subseq line 0 (min (length line) w))
+                        nil nil))))

src/components/theme.lisp

@@ -26,16 +26,20 @@ NAME should be a keyword (e.g., :default, :nord)."
   `(setf (gethash ,name *presets*) '(:dark ,dark :light ,light)))
 
 (defun load-preset (theme preset-name)
-  "Load PRESET-NAME (a keyword) into THEME, overwriting role mappings."
+  "Load PRESET-NAME colors into THEME.
+Side-effect: populates cl-tty.backend:*theme-colors* so that semantic
+color roles resolve to hex at SGR generation time."
   (let ((preset (gethash preset-name *presets*)))
     (if preset
-        (let* ((variant (if (eql (theme-mode theme) :dark)
-                            (getf preset :dark)
-                            (getf preset :light)))
-               (roles (theme-roles theme)))
-          (clrhash roles)
-          (loop for (role hex) on variant by #'cddr
-                do (setf (gethash role roles) hex)))
+        (let* ((colors (if (eql (theme-mode theme) :dark)
+                           (getf preset :dark)
+                           (getf preset :light)))
+               ;; Populate backend theme color map
+               (theme-map (symbol-value (find-symbol "*THEME-COLORS*" :cl-tty.backend))))
+          ;; Set theme colors
+          (loop for (role hex) on colors by #'cddr
+                do (setf (theme-color theme role) hex)
+                   (setf (gethash role theme-map) hex)))
         (warn "Unknown preset: ~S" preset-name))))
 
 (define-preset :default

src/rendering/framebuffer.lisp

@@ -0,0 +1,219 @@
+(defpackage :cl-tty.rendering
+  (:use :cl :cl-tty.backend)
+  (:export
+   #:cell #:make-cell #:cell-char #:cell-fg #:cell-bg
+   #:cell-bold #:cell-italic #:cell-underline #:cell-link-url
+   #:framebuffer-backend #:make-framebuffer-backend
+   #:make-framebuffer #:fb-framebuffer
+   #:framebuffer-width #:framebuffer-height
+   #:diff-framebuffers #:flush-framebuffer
+   #:with-scissor
+   #:extract-text #:fb-cell-link-url))
+
+(in-package :cl-tty.rendering)
+
+;;; ─── Cell — immutable per-cell state ─────────────────────────────────────────
+
+(defstruct cell
+  "A single terminal cell — character, colors, and attributes."
+  (char #\space :type character)
+  (fg nil)
+  (bg nil)
+  (bold nil :type boolean)
+  (italic nil :type boolean)
+  (underline nil :type boolean)
+  (link-url nil))
+
+;;; ─── Framebuffer — 2D array of cells ────────────────────────────────────────
+
+(defun make-framebuffer (width height)
+  "Create a 2D array of CELL with dimensions HEIGHT x WIDTH."
+  (make-array (list height width)
+              :initial-element (make-cell)
+              :element-type 'cell))
+
+(defun framebuffer-width (fb)
+  "Return the width (columns) of framebuffer FB."
+  (if (arrayp fb) (array-dimension fb 1) 0))
+
+(defun framebuffer-height (fb)
+  "Return the height (rows) of framebuffer FB."
+  (if (arrayp fb) (array-dimension fb 0) 0))
+
+;;; ─── Framebuffer Backend — implements backend protocol ─────────────────────
+
+(defclass framebuffer-backend (backend)
+  ((framebuffer :initform nil :accessor fb-framebuffer)
+   (scissor-x :initform 0 :accessor fb-scissor-x)
+   (scissor-y :initform 0 :accessor fb-scissor-y)
+   (scissor-w :initform nil :accessor fb-scissor-w)
+   (scissor-h :initform nil :accessor fb-scissor-h)))
+
+(defun make-framebuffer-backend (&key (width 80) (height 24))
+  "Create a framebuffer-backend with a fresh framebuffer."
+  (let ((fb (make-instance 'framebuffer-backend)))
+    (setf (fb-framebuffer fb) (make-framebuffer width height))
+    fb))
+
+;;; ─── Drawing methods ─────────────────────────────────────────────────────────
+
+(defun %in-scissor-p (fb cx cy)
+  "Check if (CX, CY) falls within the current scissor rectangle."
+  (let ((sx (fb-scissor-x fb)) (sy (fb-scissor-y fb))
+        (sw (fb-scissor-w fb)) (sh (fb-scissor-h fb)))
+    (and (or (null sw) (and (>= cx sx) (< cx (+ sx sw))))
+         (or (null sh) (and (>= cy sy) (< cy (+ sy sh)))))))
+
+(defun %set-cell (fb x y char &key fg bg bold italic underline link-url)
+  "Set cell (X, Y) if within bounds and scissor."
+  (let ((cells (fb-framebuffer fb)))
+    (when (and (>= y 0) (< y (framebuffer-height cells))
+               (>= x 0) (< x (framebuffer-width cells))
+               (%in-scissor-p fb x y))
+      (setf (aref cells y x)
+            (make-cell :char char :fg fg :bg bg
+                       :bold bold :italic italic :underline underline
+                       :link-url link-url)))))
+
+(defmethod draw-text ((fb framebuffer-backend) x y string fg bg
+                        &key bold italic underline reverse dim blink
+                             (link-url nil link-url-p)
+                        &allow-other-keys)
+  (declare (ignore reverse dim blink link-url-p))
+  (loop for i from 0 below (length string)
+        do (%set-cell fb (+ x i) y (char string i)
+                      :fg fg :bg bg
+                      :bold bold :italic italic :underline underline
+                      :link-url link-url)))
+
+(defmethod draw-rect ((fb framebuffer-backend) x y w h &key bg)
+  (dotimes (row h)
+    (dotimes (col w)
+      (%set-cell fb (+ x col) (+ y row) #\space :fg nil :bg bg))))
+
+(defmethod draw-border ((fb framebuffer-backend) x y w h &key (style :single) title title-align fg bg)
+  (let* ((chars (case style
+                  (:single '(#\+ #\- #\|))
+                  (:double '(#\+ #\= #\|))
+                  (:rounded '(#\. #\- #\|))
+                  (t '(#\+ #\- #\|))))
+         (tc (first chars)) (hc (second chars)) (vc (third chars)))
+    ;; Top edge
+    (%set-cell fb x y tc :fg fg :bg bg)
+    (loop for i from 1 below (1- w) do (%set-cell fb (+ x i) y hc :fg fg :bg bg))
+    (%set-cell fb (1- (+ x w)) y tc :fg fg :bg bg)
+    ;; Sides
+    (dotimes (row (- h 2))
+      (%set-cell fb x (+ y row 1) vc :fg fg :bg bg)
+      (%set-cell fb (1- (+ x w)) (+ y row 1) vc :fg fg :bg bg))
+    ;; Bottom edge
+    (%set-cell fb x (+ y h -1) tc :fg fg :bg bg)
+    (loop for i from 1 below (1- w) do (%set-cell fb (+ x i) (+ y h -1) hc :fg fg :bg bg))
+    (%set-cell fb (1- (+ x w)) (+ y h -1) tc :fg fg :bg bg)
+    ;; Title
+    (when title
+      (loop for i from 0 below (length title)
+            do (%set-cell fb (+ x 2 i) y (char title i) :fg fg :bg bg)))))
+
+(defmethod backend-clear ((fb framebuffer-backend))
+  (let ((cells (fb-framebuffer fb)))
+    (dotimes (y (framebuffer-height cells))
+      (dotimes (x (framebuffer-width cells))
+        (setf (aref cells y x) (make-cell))))))
+
+(defmethod draw-link ((fb framebuffer-backend) x y string url &key fg bg)
+  ;; OSC 8 links are not rendered in framebuffer — store as text
+  (draw-text fb x y string fg bg :link-url url))
+
+(defmethod draw-ellipsis ((fb framebuffer-backend) x y width &key fg bg)
+  (dotimes (i (min 3 width))
+    (%set-cell fb (+ x i) y #\. :fg fg :bg bg)))
+
+;;; ─── Diff ────────────────────────────────────────────────────────────────────
+
+(defun cells-equal-p (a b)
+  "Return T if two cells have identical content and style."
+  (and (eql (cell-char a) (cell-char b))
+       (eql (cell-fg a) (cell-fg b))
+       (eql (cell-bg a) (cell-bg b))
+       (eql (cell-bold a) (cell-bold b))
+       (eql (cell-italic a) (cell-italic b))
+       (eql (cell-underline a) (cell-underline b))
+       (equal (cell-link-url a) (cell-link-url b))))
+
+(defun diff-framebuffers (prev curr)
+  "Compare PREV and CURR framebuffers. Return list of (X Y CELL) for changes."
+  (let ((changes nil)
+        (h (min (framebuffer-height prev) (framebuffer-height curr)))
+        (w (min (framebuffer-width prev) (framebuffer-width curr))))
+    (dotimes (y h)
+      (dotimes (x w)
+        (let ((a (aref prev y x)) (b (aref curr y x)))
+          (unless (cells-equal-p a b)
+            (push (list x y b) changes)))))
+    (nreverse changes)))
+
+;;; ─── Flush ───────────────────────────────────────────────────────────────────
+
+(defun flush-framebuffer (prev-fb curr-fb backend)
+  "Diff PREV-FB and CURR-FB and flush changes to BACKEND.
+Returns the number of changed cells."
+  (let* ((changes (diff-framebuffers prev-fb curr-fb))
+         (count (length changes))
+         (current-row -1))
+    (when (plusp count)
+      (begin-sync backend)
+      (dolist (change changes)
+        (destructuring-bind (x y cell) change
+          (unless (= y current-row)
+            (cursor-move backend x y)
+            (setf current-row y))
+          (draw-text backend x y (string (cell-char cell))
+                     (cell-fg cell) (cell-bg cell)
+                     :bold (cell-bold cell)
+                     :italic (cell-italic cell)
+                     :underline (cell-underline cell))))
+      (end-sync backend))
+    count))
+
+;;; --- Frame inspection ---------------------------------------------------
+
+(defun fb-cell-link-url (fb x y)
+  "Return the link URL at (X Y) in framebuffer FB, or nil."
+  (when (and (arrayp fb) (>= y 0) (< y (array-dimension fb 0))
+             (>= x 0) (< x (array-dimension fb 1)))
+    (let ((c (aref fb y x)))
+      (cell-link-url c))))
+
+(defun extract-text (fb x1 y1 x2 y2)
+  "Extract visible text from the rectangle between (X1,Y1) and (X2,Y2)."
+  (let ((x-min (max 0 (min x1 x2))) (x-max (max 0 (max x1 x2)))
+        (y-min (max 0 (min y1 y2))) (y-max (max 0 (max y1 y2)))
+        (h (if (arrayp fb) (array-dimension fb 0) 0))
+        (w (if (arrayp fb) (array-dimension fb 1) 0)))
+    (with-output-to-string (s)
+      (loop for y from y-min to (min y-max (1- h))
+            do (loop for x from x-min to (min x-max (1- w))
+                     do (let ((c (aref fb y x)))
+                          (princ (cell-char c) s)))
+               (when (< y y-max) (princ #\Newline s))))))
+
+;;; ─── Scissor clipping ────────────────────────────────────────────────────────
+
+(defmacro with-scissor ((fb x y w h) &body body)
+  "Clip all drawing on FB to rectangle (X Y W H)."
+  (let ((old-x (gensym)) (old-y (gensym))
+        (old-w (gensym)) (old-h (gensym)))
+    `(let ((,old-x (fb-scissor-x ,fb))
+           (,old-y (fb-scissor-y ,fb))
+           (,old-w (fb-scissor-w ,fb))
+           (,old-h (fb-scissor-h ,fb)))
+       (setf (fb-scissor-x ,fb) ,x
+             (fb-scissor-y ,fb) ,y
+             (fb-scissor-w ,fb) ,w
+             (fb-scissor-h ,fb) ,h)
+       (unwind-protect (progn ,@body)
+         (setf (fb-scissor-x ,fb) ,old-x
+               (fb-scissor-y ,fb) ,old-y
+               (fb-scissor-w ,fb) ,old-w
+               (fb-scissor-h ,fb) ,old-h)))))

system-index.txt

@@ -0,0 +1 @@
+cl-tty.asd

tests/framebuffer-tests.lisp

@@ -0,0 +1,97 @@
+(defpackage :cl-tty-framebuffer-test
+  (:use :cl :fiveam :cl-tty.rendering :cl-tty.backend))
+(in-package :cl-tty-framebuffer-test)
+
+(def-suite framebuffer-suite :description "Framebuffer rendering pipeline tests")
+(in-suite framebuffer-suite)
+
+(test make-framebuffer-creates-correct-size
+  (let ((fb (make-framebuffer 80 24)))
+    (is (= 24 (framebuffer-height fb)))
+    (is (= 80 (framebuffer-width fb)))))
+
+(test cell-defaults-are-space
+  (let ((cell (aref (make-framebuffer 10 10) 0 0)))
+    (is (eql #\space (cell-char cell)))
+    (is (null (cell-fg cell)))
+    (is (null (cell-bg cell)))))
+
+(test draw-text-on-fb-sets-cells
+  (let ((fb (make-framebuffer-backend)))
+    (draw-text fb 2 3 "abc" :red nil)
+    (let ((cells (fb-framebuffer fb)))
+      (is (eql #\a (cell-char (aref cells 3 2))))
+      (is (eql #\b (cell-char (aref cells 3 3))))
+      (is (eql #\c (cell-char (aref cells 3 4))))
+      (is (eql :red (cell-fg (aref cells 3 2)))))))
+
+(test draw-text-clips-at-bounds
+  (let ((fb (make-framebuffer-backend :width 10 :height 5)))
+    (draw-text fb 8 2 "hello" nil nil)
+    (let ((cells (fb-framebuffer fb)))
+      (is (eql #\h (cell-char (aref cells 2 8))))
+      (is (eql #\e (cell-char (aref cells 2 9))))
+      (is (eql #\space (cell-char (aref cells 2 0))) "out of bounds text is ignored"))))
+
+(test diff-identical-fbs-returns-empty
+  (let ((fb1 (make-framebuffer 80 24))
+        (fb2 (make-framebuffer 80 24)))
+    (is (null (diff-framebuffers fb1 fb2)))))
+
+(test diff-changed-fb-returns-changes
+  (let* ((fb1 (make-framebuffer 10 10))
+         (fb2 (make-framebuffer 10 10)))
+    (setf (aref fb2 5 5) (make-cell :char #\X :fg :red))
+    (let ((changes (diff-framebuffers fb1 fb2)))
+      (is (= 1 (length changes)))
+      (destructuring-bind (x y cell) (first changes)
+        (is (= 5 x))
+        (is (= 5 y))
+        (is (eql #\X (cell-char cell)))))))
+
+(test with-scissor-clips-drawing
+  (let ((fb (make-framebuffer-backend :width 20 :height 10)))
+    (with-scissor (fb 5 5 3 3)
+      (draw-text fb 6 6 "ABC" nil nil)
+      (draw-text fb 1 1 "OUTSIDE" nil nil))
+    (let ((cells (fb-framebuffer fb)))
+      (is (eql #\A (cell-char (aref cells 6 6))) "inside scissor draws")
+      (is (eql #\space (cell-char (aref cells 1 1))) "outside scissor is clipped"))))
+
+(test flush-fb-copies-to-backend
+  (let* ((real-be (make-simple-backend :output-stream (make-string-output-stream)))
+         (fb (make-framebuffer-backend)))
+    (draw-text fb 0 0 "X" :red nil)
+    (let ((changed (flush-framebuffer (make-framebuffer 80 24) (fb-framebuffer fb) real-be)))
+      (is (>= changed 1)))))
+
+;; ── Frame inspection ──────────────────────────────────────────
+
+(test fb-cell-link-url-returns-nil-for-blank-cell
+  (let ((fb (make-framebuffer 10 10)))
+    (is (null (fb-cell-link-url fb 5 5)))))
+
+(test fb-cell-link-url-finds-link-url
+  (let ((fb (make-framebuffer-backend)))
+    (draw-text fb 0 0 "click" nil nil :link-url "https://example.com")
+    (is (equal "https://example.com" (fb-cell-link-url (fb-framebuffer fb) 0 0)))
+    (is (null (fb-cell-link-url (fb-framebuffer fb) 5 5)))))
+
+(test fb-cell-link-url-out-of-bounds-returns-nil
+  (let ((fb (make-framebuffer 5 5)))
+    (is (null (fb-cell-link-url fb 10 10)))))
+
+(test extract-text-single-row
+  (let ((fb (make-framebuffer-backend)))
+    (draw-text fb 0 0 "hello" nil nil)
+    (let ((cells (fb-framebuffer fb)))
+      (is (equal "hello" (extract-text cells 0 0 4 0))))))
+
+(test extract-text-multi-row
+  (let ((fb (make-framebuffer-backend)))
+    (draw-text fb 0 0 "abc" nil nil)
+    (draw-text fb 0 1 "def" nil nil)
+    (let* ((cells (fb-framebuffer fb))
+           (text (extract-text cells 0 0 2 1)))
+      (is (equal "abc
+def" text)))))

tests/mouse-tests.lisp

@@ -9,9 +9,41 @@
     (is-true (typep m 'mouse-mixin))))
 
 (def-test mouse-hit-test-point ()
+  "hit-test returns nil when no component has position slots bound"
   (let ((obj (make-instance 'mouse-mixin)))
-    (is-true t)))  ;; placeholder
+    (is-false (hit-test obj 0 0))
+    (is-false (hit-test obj 100 100))))
 
 (def-test selection-set-and-get ()
   (setf cl-tty.mouse::*selection* (make-selection :text "hello"))
   (is (equal "hello" (get-selection))))
+
+;; ── Selection tracking ──────────────────────────────────────
+
+(def-test start-selection-initializes-state ()
+  (start-selection 5 10)
+  (is-true (selection-active-p))
+  (is (equal '(5 . 10) cl-tty.mouse::*selection-start*))
+  (is (equal '(5 . 10) cl-tty.mouse::*selection-end*))
+  (setf cl-tty.mouse::*selection-active* nil
+        cl-tty.mouse::*selection-start* nil
+        cl-tty.mouse::*selection-end* nil))
+
+(def-test update-selection-moves-end ()
+  (start-selection 0 0)
+  (update-selection 3 7)
+  (is (equal '(3 . 7) cl-tty.mouse::*selection-end*))
+  (setf cl-tty.mouse::*selection-active* nil
+        cl-tty.mouse::*selection-start* nil
+        cl-tty.mouse::*selection-end* nil))
+
+(def-test finalize-selection-extracts-text ()
+  (let* ((fb-be (cl-tty.rendering:make-framebuffer-backend))
+         (fb (cl-tty.rendering:fb-framebuffer fb-be)))
+    (cl-tty.backend:draw-text fb-be 0 0 "hello" nil nil)
+    (cl-tty.backend:draw-text fb-be 0 1 "world" nil nil)
+    (start-selection 0 0)
+    (update-selection 4 1)
+    (let ((text (finalize-selection fb)))
+      (is (equal "hello
+world" text)))))

tests/slot-tests.lisp

@@ -0,0 +1,26 @@
+(defpackage :cl-tty-slot-test (:use :cl :cl-tty.slot :fiveam))
+(in-package :cl-tty-slot-test)
+
+(def-suite slot-suite :description "Slot system tests")
+(in-suite slot-suite)
+
+(def-test defslot-register ()
+  (clear-slot :test-slot)
+  (defslot :test-slot :order 1 :render-fn (lambda () "hello"))
+  (is-true (slot-p :test-slot)))
+
+(def-test slot-render-calls ()
+  (clear-slot :test-slot)
+  (defslot :test-slot :order 1 :render-fn (lambda () "a"))
+  (defslot :test-slot :order 2 :render-fn (lambda () "b"))
+  (is (equal '("a" "b") (slot-render :test-slot))))
+
+(def-test slot-render-empty ()
+  (clear-slot :ghost)
+  (is-false (slot-render :ghost)))
+
+(def-test clear-slot-removes ()
+  (clear-slot :test-slot)
+  (defslot :test-slot :order 1 :render-fn (lambda () "x"))
+  (clear-slot :test-slot)
+  (is-false (slot-p :test-slot)))