Option sets: a .o target for shared parameters

A named group of optional parameters, declared once and used by several
klammers, so a writer learns one vocabulary instead of a spelling per
klammer.  The "o" target is a pseudo-target beside "k": "k" declares a
klammer's interface and documents it, "o" declares an option interface and
documents it, and neither produces output for any target.

    @@caption_args.o :caption :number.bool true :caption_side.side
    : Arguments that define a caption for a block element @@

    @@code.k :filename @hpos_args :hpos left @ @caption_args :caption_side top @
    | text.literal : A source file displayed verbatim @@

A set is used only in the parameter list of a ".k" declaration -- the one
place a klammer's interface is declared once for all of its targets -- and
is resolved as that list is read.  Names and types come from the set; a
default may be overridden where it is used.  A klammer application in a
parameter list is now a definition-time error.

The SKS gains the sets caption_args and hpos_args (:hpos and :offset), and
@table, @image, @image_grid, @reference and @show gain .k declarations.  A
distance is no longer written as a position: :hpos 4em is rejected, and the
same layout is :hpos left :offset 4em.  Code listings are numbered by
default, like tables and figures.

New engine sources mac/option_set{,_registry}.{h,cpp}; tst/ ships two more
suites, option_set_test.sh and signature_test.sh (twelve in all).

 (from dev 34e536cb0329)

sks/target/css/target.css

@@ -168,6 +168,14 @@
     justify-content: left;
 }
 
+/* Retired 2026-08-03: this fixed 1em on every left- and right-placed
+   element was the :offset argument, hard coded and only in html -- the tex
+   side had no counterpart, so the two targets disagreed.  It is now the
+   offset_length argtype (sks/kutil/kutil.k), applied by
+   html_util.hpos_container and latex_util.caption_wrapper.  A document
+   that wants the old inset writes ":offset", whose alone value is the
+   standard indentation.
 .hpos_margin {
     margin: 0 1em 0 1em;
 }
+*/

sks/target/html_util.py

@@ -193,27 +193,38 @@ def element_tag(element):
 def font_class(font):
     return {"r" : "", "i" : "ritalic", "t" : "monospace", "s" : "sanserif"}[font]
 
-def hpos_container(element, hpos):
+def hpos_container(element, hpos, offset=None):
     # Wrap element in its horizontal-position container.  hpos is left,
     # center, right, none, or a length, which becomes the left margin
     # (the tex counterparts are the \LTleft glue for tables and the
     # \hspace* in latex_util.caption_wrapper).
-    style = None
+    #
+    # offset insets the element from the margin hpos names, as padding on
+    # that side of the flex container: the left for "left", the right for
+    # "right".  A centered element has no such margin, so the offset is
+    # ignored there rather than being an error -- same rule as
+    # latex_util.caption_wrapper, which is the tex counterpart.  (It
+    # replaces the fixed 1em that the hpos_margin class used to add to
+    # every left- and right-placed element: that was this offset, hard
+    # coded, and only in html.)
+    styles = []
     if hpos not in ("left", "center", "right", "none"):
         length, _, _ = kutil.parse_length("html", hpos, 1)
-        style = f"margin-left: {length}"
+        styles.append(f"margin-left: {length}")
         hpos = "indent"
+    if offset and offset not in ("0", "0pt") and hpos in ("left", "right", "indent"):
+        length, _, _ = kutil.parse_length("html", offset, 1)
+        side = "right" if hpos == "right" else "left"
+        styles.append(f"padding-{side}: {length}")
     result = E("div").cls("hpos_" + hpos).body(element)
-    if style:
-        result.attr("style", style)
-    if hpos not in ("center", "indent"):
-        result.cls("hpos_margin")
+    if styles:
+        result.attr("style", "; ".join(styles))
     return result
 
 
 def add_caption(element, caption_label, number, caption_text,
                 font_symbol="i", hpos="center", side="bottom", as_string=True,
-                font_size=.9, width=None, max_width=None):
+                font_size=.9, width=None, max_width=None, offset=None):
     tag = element_tag(element)
     # Caption
     caption = ""
@@ -263,7 +274,7 @@ def add_caption(element, caption_label, number, caption_text,
             element.attr("style", f"max-width: {max_width}")
 
 
-    result = hpos_container(element, hpos)
+    result = hpos_container(element, hpos, offset)
 
     if number:
         result.cls("element_container")

sks/target/latex_util.py

@@ -12,6 +12,31 @@ def tex_style():
 
 # \usepackage{quoting}
 
+def block(material):
+    r"""Return tex material as a block: vertical mode on both sides.
+
+    A block element -- a table, an image, a code listing -- is box
+    material.  Appended to a non-empty horizontal list (an @image written
+    after text on the same line, with no blank line between) a box is
+    typeset BESIDE the text rather than below it, and text following it
+    flows to its right.  A \par on each side ends the paragraph in
+    progress and starts a new one after.  \par in vertical mode is a
+    no-op, so this is safe wherever it is applied: a block klammer needs
+    no knowledge of what preceded it.
+
+    Every SKS klammer whose tex output is box material returns it through
+    this function.  LaTeX ENVIRONMENTS -- center, flushright, quote,
+    itemize, verbatim -- already break the paragraph themselves and do
+    not need it.
+
+    The paragraph policy this serves: in an @document, paragraphs are
+    made from blank-line-separated text (@par is the explicit form for a
+    fragment rendered without @document), and the author is never
+    required to know that a target distinguishes horizontal from
+    vertical mode.  Asserted by sks/tst/paragraph_test.sh.
+    """
+    return "\\par\n" + material.strip("\n") + "\n\\par\n"
+
 def environment(name, body, required=None, optional=None):
     req = f"{{{required}}}" if required else ""
     opt = f"[{optional}]" if optional else ""
@@ -54,17 +79,36 @@ def minipage(content, width="\\textwidth", vertical="c", center=True, vmargin=""
         result = f"\\fbox{{{result}}}"
     return result
 
-def caption_wrapper(element, hpos, bottom_margin=.67):
+def offset_length(offset):
+    r"""An :offset as a LaTeX length, or "0pt" when there is none."""
+    if not offset or offset in ("0", "0pt"):
+        return "0pt"
+    return kutil.parse_length("tex", offset, 1)[0]
+
+def offset_space(offset):
+    r"""An :offset as an \hspace*, or "" when there is none."""
+    length = offset_length(offset)
+    return "" if length == "0pt" else f"\\hspace*{{{length}}}"
+
+def caption_wrapper(element, hpos, bottom_margin=.67, offset=None):
     # hpos is left, center, right, none (no wrapper), or a length, which
     # becomes the left margin.  The element is a box on a line inside a
     # full-width minipage; \hfill on the empty side pushes it into place.
+    #
+    # offset insets the element from the margin hpos names -- from the left
+    # for "left", from the right for "right".  A centered element has no
+    # such margin, so the offset is ignored there rather than being an
+    # error: the two arguments are independent, and :hpos is what decides
+    # whether the offset has anything to measure from.  (The html
+    # counterpart is html_util.hpos_container.)
     vmargin = f"{bottom_margin}\\baselineskip"
+    inset = offset_space(offset)
     if hpos == "center":
         return minipage(element, vmargin=vmargin)
     if hpos == "left":
-        return minipage(element + "\\hfill", vmargin=vmargin, center=False)
+        return minipage(inset + element + "\\hfill", vmargin=vmargin, center=False)
     if hpos == "right":
-        return minipage("\\hfill" + element, vmargin=vmargin, center=False)
+        return minipage("\\hfill" + element + inset, vmargin=vmargin, center=False)
     if hpos == "none":
         return element
     length, _, _ = kutil.parse_length("tex", hpos, 1)
@@ -85,7 +129,8 @@ def make_caption_text(number, label, text, font_symbol, font_size):
     return caption
 
 def add_caption(element, caption_label, number, caption_text, latex_width,
-                hpos="center", side="bottom", font_symbol="i", font_size=.9):
+                hpos="center", side="bottom", font_symbol="i", font_size=.9,
+                offset=None):
     top_margin = .75 if "includegraphics" in element else .5
     caption = make_caption_text(number, caption_label, caption_text, font_symbol, font_size)
     if caption:
@@ -118,4 +163,4 @@ def add_caption(element, caption_label, number, caption_text, latex_width,
             # space below its line.
             element = minipage(caption + "\\rule[-0.75\\baselineskip]{0pt}{0pt}\n" + element,
                                latex_width, vertical="t")
-    return caption_wrapper(element, hpos)
+    return caption_wrapper(element, hpos, offset=offset)