Skip to content

v0.13.0

Latest

Choose a tag to compare

@github-actions github-actions released this 12 Nov 09:34
· 20 commits to main since this release
f428fee

Upgrading from 0.12.0.

  • The depth map of every panel with a ground, floor, water or ceiling changes once (#227),
    and with it the bytes of its .depth.svg: regenerate golden depth maps of your own. Nothing
    else changes, Panel Core included.

Added

  • The front door and the story (#323). The README and the site's landing page open the
    same way: the gallery tour's picture, one sentence on what Scenet does today, buttons to the
    playground, the gallery and the install guide, the AI-generated notice word for word, and a door
    for each reader: Discover, Write comics, Build with Python, Drive from a model, Contribute. The
    README is the PyPI page too, so every link in it is absolute and it stays under 120 lines; a
    test holds it to both. About gains Why Scenet, the score-and-performer thesis rewritten for
    what Scenet is now, with the style layer defined; What Scenet does today, a feature matrix in
    place of the phase log, whose every "since" is checked against the releases mined from the tags
    and the CHANGELOG, unreleased work marked; and What's new, this file. The navbar reads Learn,
    Guides, Language, Python API, Gallery, Playground, About, with Contribute in the footer; the
    how-to guides are grouped by what the reader is doing, a line each; and Use the playground
    documents every button, Puppet… included, which a test holds to the page's toolbar.
    Design decisions is named so and grouped by theme, the PDF print spike is a design note marked
    superseded, the glossary gains character, scene, sequence, page, book and retreat, and reader
    pages say what a thing does rather than which issue added it.

  • One umbrella panel. The gallery's 01-two-characters is the example every page shows: the
    README, the landing page, the skill and the Python track. The language reference's complete
    example, gallery 71, is that panel with a setting, and a test holds every copy to it. The six
    files at the top of examples/ are folded into the gallery, whose files the reference's commands
    now name.

  • Learn Scenet from Python (#322): the developer's track, five chapters under
    docs/tutorial/python/, from pip install scenet to Scenet inside a program of your own.
    Compile and render calls every compile_* entry point and every renderer, writes files,
    and hands fonts and pictures back with fonts= and embed=; Read what it decided reads
    a Panel Core as objects and as JSON, edits one and draws it again, and shows determinism;
    Errors and notes walks the ScenetError tree, a fault's rule and place, and notes
    matched by their codes; Bring your own adds a puppet library, a font as metrics=, a
    document's files as base=, and a picture; Outputs, batch and CI builds a folder,
    keeps golden files, runs scenet check, writes SARIF from Python, and calls the MCP tools
    and server in process. Every example is a complete script followed by what it prints:
    the test suite runs each one alone, in a folder holding the documents its chapter saved,
    and compares its output with the page. tests/test_python_track.py holds every chapter
    to its parts, its examples to their output, and the track to every public compile_* and
    render_* function, each called and linked to its reference page. The Tutorial page now
    leads to both tracks.

  • The author's tour (#321): twelve chapters under docs/tutorial/, from a first panel to
    a printed page, comic scripts, art and puppets of your own, right to left, and what Scenet
    tells you. Each shows what you will make, as a gallery picture, beside its complete
    document; builds it and says what the compiler decided; opens its examples in the
    playground; runs scenet check; and links the key cards and the diagnostics entries. The
    gallery's groups are now the tour's chapters, in its order, in the playground's menu too,
    and the Gallery page sends each group to its chapter. tests/test_tutorial.py holds every
    chapter to that shape, every "Try it" list to its group, every printed output to what the
    command prints, and the tour to the whole language: every key of a panel or a scene, and
    every top-level key of a puppet file and an artwork contract, is written in a chapter's
    document and linked to its card. The first chapter, first_panel.md, is rewritten for an
    author: it installs with uv tool install, builds the file it wrote, and names a note by
    its id.

  • The install guide names the mcp and watch extras.

  • A documented command runs on the files its page wrote. A bash block in the docs now
    finds every file a block above it, captioned with a file name, shows, and the gallery's
    pictures, fonts and puppets; a line ending in # exits 1 must exit 1, so a page can show
    scenet check failing on a mistake. A captioned copy of a gallery example counts as that
    example.

  • The command-line reference is complete (#320). Every option of every command has an
    example, which the test suite runs -- a --watch example runs its first build -- and every
    command and option says the release it appeared in, mined from the tags into
    docs/reference/cli.since.toml by scripts/mine_cli_since.py: --pdf, --mono, --watch
    and --puppet are 0.13, not yet released. scenet schema has an exit-status table, held to
    a scenario for each code as the other commands' are. Each rule in the table of rules links
    its entry in the diagnostics reference. A test fails on an option without an example or a
    release, and on an issue number in the page.

  • A finding links its entry (#320). SARIF gives every rule a helpUri, its entry in the
    diagnostics reference, and its help ends by naming that entry, in text and in Markdown, so
    code scanning and an editor send a reader to why it happens and how to fix it. The MCP
    server's findings carry the same address as help_uri, and the VS Code extension opens the
    rule's own entry from Problems rather than the list of every rule.
    scenet.diagnostics.help_uri gives the address for an id. puppet-file's help names the
    published how-to instead of a path in the repository. The spec pack's diagnostics part
    and the skill's references/diagnostics.md are the reference page itself, entry for entry,
    with its documents and their fixes, the compile notes included; a cross-reference to the
    Python API in any page the pack carries is printed as code instead of as raw MyST.

  • A diagnostics reference (#320), as Rust's error index is: an entry for each of the 37 rules
    scenet check reports and each of the 8 notes the compiler gives, at
    docs/reference/diagnostics.md. An entry gives the id, its level, what it says, why it
    happens, how to fix it, the keys that can give it, the release it was first given in and the
    gallery examples that show it -- then a document that gives it, what scenet check or
    scenet build prints of that document, and the same document fixed. The page is generated by
    scripts/build_diagnostics.py from the catalogue and tests/rule_corpus/, which gains a
    fixed twin for every document in fixed/ and a document for every compile note; the test
    suite holds each document to giving exactly its diagnostic and each twin to giving nothing.
    The compile notes are described in a new catalogue, scenet.diagnostics.COMPILE_NOTES, as
    the rules are. Every key card links the entry of each diagnostic it can give, compile notes
    included, and every entry links back to its keys. The gallery's "Read about it" for the
    examples of "What Scenet tells you" opens the entry of the note they show. A
    {scenet-example} can show a fault on purpose with :gives: <id>: the build fails unless the
    document gives exactly that. "Since" is mined from the release tags into
    docs/reference/diagnostics.since.toml.

  • Every key of the language has a card (#319), as a cppreference entry does: all 128 keys a
    panel, a scene, an artwork contract or a puppet file can write. A card opens on the key's
    meaning -- the line an editor shows on hover -- then a table of where it is written (in a
    document and in a comic script), its type, values, default, the release it appeared in, the
    findings it can give and the gallery examples that show it; then what it means, how it
    resolves against everything else and its limits; then a minimal document, compiled when the
    documentation is built by a new {scenet-example} directive and shown with its picture and an
    "Open in the playground" link. The facts are generated from the published schemas by
    scripts/build_language_pages.py, between markers, and a test fails on a key without a card,
    a card for a key that does not exist, a stale table or an example that does not compile.
    "Since" is mined from the editor's schemas at each release tag into
    docs/reference/language/since.toml, values added later marked on their own (warm, 0.13).
    Every default an audit found unstated is now stated, the nine placement zones are listed, and
    the missing sections are written: the scene document (panels, over, the merge rules and
    null), the staging mapping form, setting's own keys, the camera's retreat, puppet files
    and artwork contracts. An All keys, A to Z page lists every key, and a glossary says
    what the reference's words mean. The gallery's "Read about it" opens the card of the key an
    example shows, and unknown-key and invalid-field send a reader to the index. The spec pack
    and the skill print each card's example as YAML and each included file in full.

  • The language reference is a page per block (#319). docs/reference/language/ holds an
    overview, the blocks, a complete example, conflicts and determinism, then a page each for
    panel, camera, setting, cast, staging, script, description, lettering,
    direction, palette, and page and pages. The old page keeps each heading it had, with a
    link to its new home, so a link written before the split still lands on what it named. The
    gallery's "Read about it", every page of the documentation, the spec pack's language part
    and the skill's references/language.md follow the pages; a rule's help names the published
    reference instead of a path in the repository.

  • Every key a document can write says what it means on hover (#319). The editor's four JSON
    Schemas -- panel, scene, artwork contract and puppet -- give each key a description of its
    own, one paragraph, where 4 of 77 had one: the meaning now sits under each field in the
    models, which the Python reference shows too. A definition's description is its summary
    alone, and no description carries a Sphinx role, a docstring section, a doctest, an issue
    number or the repository's own agent instructions. A test fails on a key without a
    description, and on any of those. llms.txt and the spec pack's schema part list all four
    schemas, and the line describing the command line names scenet schema. The copies the site
    serves for one version link that version's pages, pictures and schemas, /dev/ or /vX.Y/;
    the committed copies link the root, as before.

  • Every public name explains itself as a reference entry (#318). Each name in
    scenet.__all__ has a summary, an example that imports it from scenet and shows its
    output, and See also; each function its parameters, what it returns, exactly which public
    errors it raises and when, and a note on its limits. A test over __all__ holds each to it.
    Issue numbers are gone from every docstring, which says what the thing does instead.
    CompileResult's core, placements and posed are described, so the reference lists
    them, as are 68 other fields no description reached, and a test fails on a field of an
    exported model left undescribed; a field described with Field(description=...) is shown
    with it. Fourteen Returns: sections no longer render their first words as a type, and a
    test keeps them so. An alias such as FaceMark reads FaceStroke | FaceDisc, without
    pydantic's metadata. panel_core.md has a table of every Panel and Page Core field, made
    from the models. The library guide covers all seven renderers, books and pages, fonts=,
    embed= and metrics=, building a panel in Python, the Core object model, and threads,
    caches and the files a compile reads. The editor's JSON Schemas leave a docstring's Python
    sections out of a description, which an author writing YAML has no use for.

  • The Python reference has a page for every public name (#318). Each opens on a card -- its
    import line, the module that defines it with a link to its source, what to install, the
    release it appeared in and how stable it is -- then its signature and docstring. A function
    or main class has a page of its own; enumerations share one per group, and so do the errors.
    scripts/build_api_pages.py writes them, and the index's overview, from __all__'s own
    groups, where the hand-kept table had left out 25 names; --check and a test fail on a
    stale page. "Since" is mined from __all__ at each release tag into
    docs/reference/api/since.toml, with each parameter a function gained later marked
    versionadded; a test fails on a public name without one. The module pages now document the
    internals alone, marked as outside semantic versioning. A Guarantees page says what stays
    stable, what determinism covers, what threads may share and which caches they do, which files
    a compile reads, and how long it takes. FontMetrics, which metrics= and fonts= take, is
    importable from scenet.

  • The print PDF says what its colours are (#283). RGB pictures are tagged with the ICC's
    sRGB profile, shipped in the package and written once per file; grey pictures and CMYK JPEGs
    keep their device space. An output intent names the printing condition the CMYK twins were
    made for, CGATS21-2-CRPC6, by its registry identifier, without embedding its profile. Every
    page blends its transparency in CMYK, and the file says it is not trapped. No PDF/X
    conformance is claimed: no free tool can check it. A test holds every gallery PDF to the
    PDF/X-4 requirements the writer can meet, and the print how-to says what is missing and how a
    printer converts the file.

  • Panels that bleed past the trim (#281). A page placement's bleed: true runs its frame out
    to the bleed line on every side that reaches the page's margin, bleed: [top, left] on those
    sides; no border is drawn there. The cast is staged in what the reader sees, out to the trim,
    and lettering keeps inside the frame as it was, so the trim cuts neither. Panel Core gains
    open and lettering, a Page Core frame bleed, each only where something bleeds. Gallery
    example 73 writes every form of the key.

  • A tinted palette prints in colour (#280). Every colour the compiler owns has a CMYK twin
    under CGATS21-2-CRPC6 (GRACoL 2013), converted from its sRGB colour through the condition's
    ICC profile with littleCMS, relative colorimetric with black point compensation, and committed
    as scenet.emit.cmyk; scripts/make_palette.py generates it and --checks it, with the
    profiles in scripts/profiles/ and Pillow as a pinned dev dependency. The print PDF draws a
    tinted mass, veil, rain and warm caption in its twin, lettering staying 100% black over it.
    --mono and render_pdf(..., mono=True) print the greys instead: the same file as the
    document's palette: mono twin. A colour none of the palette's prints its grey, with a note;
    the note that a tinted panel prints in its greys is gone. Greys follow the same condition: a
    grey prints on black alone at the K that prints its lightness there, read from black's ramp
    measured through the profile, where K = 1 − L printed far too light (#707070 went from K 45%
    to 69%), so every PDF's greys move once. The tints and the ramp were checked against the
    profile, never on paper.

  • The fog and cloud veil in print (#282). The print PDF drew no veil, and said so; it now
    carries the same noise the SVG's feTurbulence draws, computed by the compiler from SVG 1.1's
    reference algorithm and laid over the veil's ink as a soft mask, where the SVG paints it, at
    127 dpi. Where the reference code would divide by a zero gradient, the gradient stays zero, as
    Chromium keeps it. scenet.emit.turbulence computes it, in numpy, to the same bytes everywhere;
    print_notes no longer mentions the veil.

  • Live text in the print PDF (#284). scenet build --pdf --live-text, render_pdf(..., live_text=True) and the playground's Print tab with live text on letter balloons and
    captions as text, so the words can be selected, searched and copied. Each face is embedded
    as a subset of the glyphs it draws, at its own glyph ids, and every glyph lands where its
    outline would, at the advance and kerning the solver measured. A face goes in only where
    its licence allows: the font's OS/2 fsType is read as the OpenType specification says,
    and a face that may not be embedded, or a CFF2 one, keeps its lettering in outlines, with a
    note. Sound effects stay outlines. Outlines remain the default, and no PDF changes unless
    asked. scenet.emit.pdf_fonts carries a face; FontMetrics keeps its bytes and gives a
    character's glyph id.

  • The README shows the gallery's tour (#243), as scenet build draws it, and links the
    Gallery page. The picture is fetched from GitHub by its full address, so PyPI's project page
    shows it too.

  • Every section of the language reference shows its construct (#243): a picture of a gallery
    example, and a link to each example whose doc: names the section, on the Gallery page. A test
    holds every section to it, or to a written reason for showing nothing, such as Determinism's.
    The spec pack and the agent skill carry the same pictures and links.

  • Gallery examples 71 and 72 (#243). 71 is the language reference's complete example, a
    test keeping the two identical, so the reference can show what it compiles to. 72 shows one
    shore under each horizon, which no example showed before. Example 69 now reads about its
    puppet in the language reference's section on puppets of your own.

  • A Gallery page in the documentation (#243), beside the tutorial: every example the
    playground offers, in its menu's order and under its groups, each with its summary, its
    pictures, a link that opens it in that version's playground, the page that explains it and
    its source. Each picture's alternative text is what its SVG says to a screen reader.
    scripts/build_spec.py writes it from the manifest, and a test fails if it is stale.

  • A picture of every gallery example, for the documentation (#243). docs/images/gallery/
    holds each example drawn whole, as scenet build writes it: its pages, or else its strip, or
    else its one panel, with the picture it is lettered over written in. update_golden.py
    rewrites them with the goldens and a test holds each to its digest, so none can drift from
    what the compiler draws. The home page and the palette section show theirs from there.

  • How-to: Print a comic (#80): a page's printed size and bleed, what prints in which ink,
    what print leaves out, and checking the plates with Ghostscript. The design decisions record
    why print is an emitter from Core rather than a converter, and the black-plate rule.

  • Print in the playground and the gallery (#80). The playground's Print tab shows a
    document's print PDF in the browser's own viewer, with what print leaves out, and Download
    saves it. Gallery example 70 is a US comic page made for print, with its bleed.

  • scenet build --pdf (#80) writes the document as one print PDF beside its SVGs, a
    PDF page per page or per panel, with what print leaves out said in notes. -o still names
    the SVG; a .pdf there is refused.

  • A page prints at a size, with a bleed (#80). A page unit prints as a tenth of a
    millimetre, so the default page is 200 × 300 mm and a US comic is
    size: [1682.75, 2603.5]. page: {bleed: 31.75} runs the printed sheet 0.125 in past the
    trim on every side; nothing on the page moves, and a page without it is what it was. A
    panel can bleed into it since #281.

  • A print PDF, from Python (#80): render_pdf draws a document as a PDF a printer
    takes. Lettering, balloon borders and every line are 100% black and overprint, so type stays
    sharp when the colour plates drift; the paper knocks out; greys are black tints; the night
    foreground prints rich black; a tinted palette prints its colours' CMYK twins (#280). A page
    unit prints as 0.1 mm. The file is byte-identical from run to run, with no date in it. Supplied
    pictures go in with their pixels unchanged: a JPEG and most PNGs as the file's own data, the
    rest decoded and stored uncompressed, alpha as a soft mask. print_notes says what print leaves
    out or changes, and names a picture that prints below 300 dpi.

  • A puppet of your own, from a document (#242). A cast member names a *.puppet.yaml file
    by its path, relative to the document, as it names a font or a picture:
    reference: puppets/pip.puppet.yaml. So scenet check and scenet build read it beside the
    document, --watch rebuilds when it changes, the playground has Puppet… beside
    Font… and Image…, and the MCP server takes it in files, where list_puppets now
    describes it too. A reference that does not end in .puppet.yaml is a shipped puppet's name,
    as before, and Panel Core records the reference as written, for the camera as for the actor.
    A file that is absolute, missing or not a puppet is the new rule puppet-file: in the puppet
    file, at the key that is wrong, when the document is checked as a file, and on the line naming
    it otherwise. scenet check and scenet build refuse a puppet file given as a document.

  • scenet schema --puppet, the JSON Schema for a puppet file, so an editor completes and
    checks a *.puppet.yaml as it does a panel. It is the model's own, plus every landmark
    required, head_top zero and a standing_neutral pose. The VS Code extension ships it for
    every *.puppet.yaml, the site publishes it beside artwork.schema.json, and a test fails
    if the site leaves off a schema the extension ships.

  • Pip, the gallery's own puppet (#242). A child five heads tall, where alice and bob are
    both seven and a half, with a knot of hair, cast beside alice in example 69 in every pose and
    expression it has. The coverage test holds a puppet the gallery ships to that as it holds the
    shipped ones, and the spec pack prints it after its example.

  • The gallery writes the comic-script format in full (#241). Six scripts, 63 to 68, each in
    a convention writers use: one kept in Markdown, a manga read right to left over two pages, two
    French planches that walk the shot ladder in abbreviations and in full, one written like a
    screenplay, and a letterer's script after Blambot's. Between them they write every word a cue,
    a caption or a sound may carry in parentheses, every French shot and angle, every keyword a
    heading or a label opens with, every directive, and the forms of line no table holds, from a
    heading in Markdown to a panel before the first PAGE. A new test reads them as the script
    frontend reads them, from its own tables and patterns, so a word or a keyword the frontend
    gains fails it until an example writes it. Write a panel as a comic script links each
    convention to its example in the playground.

  • A Try it link over a gallery example's try-this. The playground puts it over the
    # Try this: comment, and it uncomments the line under it, # and all, as one edit Ctrl+Z
    takes back. Deleting only the # by hand left a space too many, and a comic script, whose
    try-this ends its front matter, has no comment for Ctrl+/ to toggle.

  • The gallery shows what the checker and the compiler tell you (#240). A new group,
    What Scenet tells you, has an example for every note: word-limit, panel-count,
    looks-like-dialogue and dropped-relation from scenet check, and from the compiler a
    camera that retreats, a tail that bends around a face, a mouth a picture's fit crops away,
    marks cut off by the frame, an inset over a face, a slant through a face, and a regular face
    standing in for the italic and bold italic ones a document did not name (examples 53 to 62,
    and 10). Each says what to change to make its note go away, and ends with a commented line
    that, uncommented, is an error located on that line. The manifest declares the notes each
    example gives under notes:, and the tests hold every example to exactly those: eight older
    examples gave camera-retreated without anybody checking, and now say so.

  • Every compile note has a name. CompileResult.compile_notes gives each note with what
    kind it is — camera-retreated, curved-tail, cropped-mouth, cropped-marks,
    inset-covers-face, slant-cuts-face, italic-stand-in or bold-italic-stand-in — as a
    CompileNote, exported beside CompileResult. notes still gives the sentences, word for
    word: match on the name, which stays when a sentence is reworded.

  • The playground lists what scenet check notes, each under its rule and a click away
    from its line, as an error is, then what the compiler noted, under its name. A check's note
    was a squiggle in the editor and nothing more.

  • The gallery writes every construct of the language, and a test reads it against the
    schemas (#239).
    Eleven examples, 42 to 52: a font of your own (Comic Neue, in
    examples/gallery/fonts/ with its licence), a sound pulled toward a zone from its source,
    the five zones between the corners, a description, staging spelled out as subject, predicate
    and object, a mass in front of the cast, a document of two pages with an inset read after its
    panel, leaving somebody out with null, a look at a voice from off panel, puppets that become
    a picture's figures, and a JPEG. scripts/make_gallery_photo.py paints the JPEG and encodes it
    itself. The coverage test now walks each document beside the published panel and scene
    schemas, so a word in a comment no longer passes it: every property, enum value, form and
    signed number they offer must be written, as must the removals the docs teach, every pose and
    expression of every puppet, a second page, and both picture formats.

  • The playground's gallery is a guided tour (#237). It opens on a new example,
    38-tour.scene.yaml: one page lettered over both gallery pictures in colour, with posed
    puppets, figures a picture draws, a locale caption, a thought, emanata, a sound effect and an
    inset. The menu groups the examples by theme, Previous and Next walk them in that order, and
    under the editor each says in a sentence what it shows, with a link to the page of the
    documentation that explains it. #example=<file> opens a gallery example by name, a link
    that does not go stale as a #src= share link does when the example changes.

  • The playground shows every output (#238). Depth, Mask, Pose, Boxes and Semantics tabs
    show the exports for image models of every panel of any document, side by side under each
    panel's name, made only while one of them is open. A Screen reader tab lists what a
    screen reader is given: every image and group the SVG names, nested, with its words. A
    Files tab shows the files beside the document: the gallery's pictures and artwork
    contracts, and the fonts and pictures you add. An Output menu letters with live text, as
    --live-text does, and shows a document of several panels as its pages, a strip, or each
    panel on its own. A document of several panels downloads its exports as one ZIP, each file
    named as scenet build --conditioning names it.

  • scenet.emit.preview draws the pose and the boxes to be looked at: each actor's skeleton
    in OpenPose's colours, and each box labelled with its phrase in its region's colour in the
    mask. scenet.emit.export.conditioning_archive puts every panel's exports in one ZIP, the
    same bytes on every run and every platform.

  • The gallery manifest gains groups:, start:, and group:, summary: and doc: on
    every entry
    , and its titles are short names. Entries are only ever appended, as its header
    now says: a playground draft remembers its example by position. The spec pack prints each
    example's summary under its title.

  • scenet build --watch (#78) rebuilds when the source or compilation dependencies change,
    with debounced saves and recovery after failed builds. The optional watch extra installs
    the file-watching dependency.

  • The tinted ladder (#244), the first step of the colour policy: the value ladder in
    colour, each value with the OKLab lightness of the grey on its rung, so that a panel drawn in
    it is, in monochrome, the panel drawn in greys. Each hour has a shadow hue at the foreground and
    an atmosphere hue at the sky, and the rungs move between them. TINTED in
    scenet.solve.backdrop is generated from those two ends by scripts/make_palette.py, and
    scripts/setting_sheet.py --palette tinted draws every place and weather in it.

  • palette: mono | tinted (#244), what a panel is drawn in. tinted draws every value on the
    ladder (the masses of a setting, the veil and the rain) in its twin colour. mono, the default,
    is what every panel already was. It is written where lettering is: at the top of a panel, beside
    panels: for every panel, on one panel for that panel alone, or in a comic script's front matter
    or as @palette:. A panel may have its own, for a flashback in grey on a page in colour. Panel Core
    keeps every grey where it was and adds colour beside it (fall_colour for rain), with palette
    at the top, all left out in mono: no existing Core, SVG or export changes. Every decision is
    still made on the grey, so a tinted Core with its colours taken out is the mono one. The pose,
    boxes, depth and mask exports are the same in every palette, and the semantics names the palette
    when it is not mono. Palette is exported, and colour_for gives a grey's twin.

  • scenet build --mono (#244) draws a tinted document as a black-and-white edition, without
    editing it: every value as its grey, and every panel, page and strip byte-identical to what the
    same document writes with palette: mono. render, render_page, render_pages and
    render_strip take mono=True, MCP render takes mono, and PanelCore.as_mono() gives the
    panel with its colours taken back out, which is the mono Core.

  • tone: warm (#244), the yellow locale caption that #28 left out for want of a colour policy.
    Its value is the day row's atmosphere rung, #eeeeee, taken by index as pale and ink are,
    and it is lettered in ink. Under palette: tinted its box is drawn in that grey's twin, the pale
    yellow #fef0a1, which the ink reads on at 16:1. In mono it is the grey, which is what a
    black-and-white reprint does to a yellow caption. Panel Core records the yellow as the caption's
    colour, beside fill, and leaves it out in mono. paper, pale and ink stay neutral in
    every palette.

  • Colour in the gallery and the reference (#244). Two gallery examples, Every hour in colour
    and A flashback in grey, join A yellow caption. The language reference has a palette
    section with both pages as pictures, and warm in the tone table. Panel Core's reference
    documents the colour keys, and the design decisions record why colour is a twin of value.

Changed

  • CI measures coverage on Python 3.14 only. The 90% branch-coverage gate stays on the Linux
    3.14 job; the 3.12, 3.13 and Windows jobs run every test, doctest and documentation example
    with --no-cov. Before 3.14, coverage cannot use sys.monitoring for branches, and its
    tracer made the required 3.12 job the one every pull request waited for. A test holds the
    workflow to it.
  • The fix for puppet-file names scenet schema --puppet (#271), as the fix for
    artwork-contract names --artwork, and the asset-contract reference names the schema
    beside the puppet it shows. A test runs every scenet schema command a fix names, so a fix
    cannot point at a schema the command does not print.
  • scenet build --watch keeps one file watcher open (#266), where it opened and closed one
    about ten times a second, and watches each folder without its subfolders: a document at the
    root of a project no longer has its .venv or node_modules watched. The watcher moves only
    when a rebuild reads other files, or a missing folder appears. A file is read and hashed again
    only once its size or modification time moves, so fonts and pictures are no longer reread on
    every poll, with or without watchfiles; touching a file still rebuilds nothing. A file
    written less than two seconds before a poll is hashed again at the next one, so a save that
    keeps both its size and its timestamp (FAT, some network shares) is still seen.
  • A note in the playground is styled as information, neutral and marked ℹ, not as an
    orange warning: nothing is wrong when the compiler says what it decided.
  • The gallery's CI job drops the notes the manifest declares before code scanning
    (scripts/check_gallery.py), so the examples that give a note on purpose open no alert. An
    error, or a note nobody declared, is still uploaded and still fails the job.
  • lightness and contrast_ratio refuse a colour (#244) with a ValueError, rather than
    answer for it with a formula that is exact only for a neutral grey. Every decision the compiler
    makes from a value is made on the grey.
  • A ground, floor or stretch of water recedes in the depth export (#227), instead of standing
    as one flat grey that a depth model reads as a wall. Each is a straight vertical ramp from its own
    step at the horizon to the farthest figure's step at the bottom edge, white when every figure
    is; a ceiling is the same ramp running up to the top edge. A flat surface's inverse depth is
    linear in screen height, so the straight ramp is the shape perspective gives. The ramp is never
    darker than its plane's step, so the painter's order holds, and never paler than a figure
    standing on it. A ground in the foreground plane stays flat, and so does every other kind. Each
    ramped region's paint names its step as the fallback. A hand-edited Core with no horizon has
    each surface recede from its own far edge.

Fixed

  • A YAML document's PanelSyntaxError carries its rule and place (#322). A fault
    validation found reached a caller with rule=None and loc=(), only the message saying
    what and where, though a comic script's error already carried both. Now rule and loc
    are those of the first fault, as scenet check orders them; a fault in a panel of a scene
    keeps its rule, and its loc starts at panels and the panel's name, as every other
    fault in a scene's does.

  • Build and check a comic in CI installs the current release. Its workflow pinned
    scenet==0.10.0; it pins 0.12.0, and a test holds the pin, and the release the page says
    it was checked with, to the version in pyproject.toml.

  • The language reference states what the compiler does (#319). panel.size was called
    required; it is [1000, 1000] when left out. The caption key table left out the warm tone.
    The shot-type reference said a panel may raise its footroom, which no key does: each shot
    sets its own. "Five authored layers" left out lettering, palette, direction and
    description, which the opening table now lists. The spec pack and the skill said two
    figures need a left-to-right order; the compiler orders them by at:, then by actor id,
    and the reference now says so and recommends stating the order with left_of. Issue
    numbers are gone from the page, and a test keeps them out.

  • The Python API reference renders (#316). Every version of the site since v0.8 showed it
    as raw reStructuredText: .. py:class:: as text, sphinx_autodoc_typehints noise, and
    doctests run together into one paragraph. Its pages called autodoc from MyST fences, which
    read autodoc's output as Markdown, so objects.inv held no Python object, none of the
    guides' {func} links went anywhere, and no page linked its source. Autodoc now runs in
    {eval-rst} fences, and docstrings are reStructuredText throughout: their nine Markdown
    tables are grid tables, and their Markdown headings, links and indented examples are rST.
    The documentation build now fails on a reference that reaches nothing (nitpicky), on raw
    markup on any built page, and on a name in scenet.__all__ that objects.inv lacks. Each
    field is documented once: undoc-members: False, which Sphinx reads as on, is gone. Enum
    members stay; __new__ on every StrEnum and pydantic's validators go. Side,
    TypeSize, CoreImage and CoreModel join their modules' __all__, and the ten modules no
    page documented are on the reference.

  • Every example works pasted into a fresh file, and every document shown compiles (#317).
    Docstring examples ran in their module's globals, so 37 called what they document without
    importing it; each now runs with builtins only, and imports what it uses. Each Python block of
    a page runs in a namespace of its own, where two leaned on the block before. A public name is
    imported from scenet, which 19 docstrings imported from the module defining it. Every yaml
    and comic-script block in the documentation and the README is compiled as the document it
    shows: the README's comic script, and the how-to's first one, which named a cast they never
    declared, now carry their front matter, and the language reference's short examples are
    complete panels. A block that is only a part of a document says so in a caption, Part of story.scene.yaml, and comic scripts are fenced as scenet-script. A test fails on each of
    the four mistakes; CONTRIBUTING.md and the testing guide state the rule.

  • except ScenetError catches every error a public call raises (#318), as scenet.errors
    promised and 34 plain built-in raises denied. Each keeps the built-in it was, so an except
    written for that still works. New, all importable from scenet:

    • RenderError, a ValueError: a renderer was not handed a font the Core was lettered in,
      a picture's bytes, or a panel a page places; was handed nothing to draw, or panels read two
      ways; or a picture print cannot carry.
    • UnknownActorError, a KeyError: PanelCore.actor and PanelCore.speaker, for a name
      the panel does not hold.
    • FileReadError, an OSError with the system's errno, strerror and filename, and
      MissingFileError, also a FileNotFoundError: every function that takes a path, for a
      file it cannot read.
    • MalformedAssetError, an AssetError and a ValueError: load_puppet for a file that
      is not a well-formed puppet, which was pydantic's ValidationError;
      PuppetLibrary.from_directory for a name declared twice; a font file that cannot be
      measured.
    • CoreSyntaxError, a SourceError: PanelCore.from_json and PageCore.from_json, which
      raised json.JSONDecodeError or ValidationError.

    compile_book_file and compile_document raise SourceError for an extension no frontend
    reads, and a document that is not UTF-8 is a PanelSyntaxError under rule syntax, where it
    was a UnicodeDecodeError. UnknownPoseError and UnknownExpressionError, which
    PuppetSpec already raised, are importable from scenet too. An except pydantic.ValidationError around load_puppet, or except json.JSONDecodeError around
    from_json, no longer catches; except ValueError does. Building a model yourself, such as
    PanelIR(...), still raises pydantic's ValidationError, as scenet.errors now says. A test
    fails on any plain built-in raised where a caller could see it.

  • A right-to-left document without pages prints right to left (#296). Its print PDF, one
    page per panel, did not say /Direction /R2L, which only pages read right to left wrote, so
    a reader laid it out left to right.

  • The playground's print PDF is the one scenet build --pdf writes (#294). It carried the
    picture of a panel no page places, which nothing draws, and refused the whole document when
    that picture was one print cannot carry, such as a lossless JPEG. render_pdf now takes only
    the pictures of the panels it prints.

  • scripts/build_site.py builds on Windows. It read the releases gh lists in the system's
    code page rather than in UTF-8, so a curly quote in a release's notes stopped the build
    before it downloaded anything.

  • The spec pack's pictures are on the site. The language reference shows two pictures for
    palette, and the spec pack and the agent skill, which carry the reference with every link
    made absolute, linked them at images/palette/ on the site, where nothing was: Sphinx serves
    a page's pictures from _images/. Each version of the site now serves docs/images/ at
    images/.

  • Add your own character is rewritten around a puppet file a document casts (#242). It said
    puppets have no expressions, though both shipped ones have ten, and its sample puppet named
    joints it never declared. It now shows the gallery's pip in full, as the file it is, says how
    to cast one from a document, the command line, the playground, MCP and Python, and lists every
    fault validation catches.

  • A fault in a puppet is said at the key that is wrong. The checks of a whole puppet — a
    landmark out of order, a joint naming a parent that does not exist — reported it at the top of
    the file; each now names its key, worded as before.

  • A puppet must declare standing_neutral, the pose a cast member gets when it names none.
    Without it every such member was unknown-pose, each on its own line, and nothing said the
    puppet was what was wrong; now it is one finding, at the puppet's poses.

  • scenet check reads the shipped puppets once per document, as its reference always said,
    rather than once for every panel it checks.

  • A numbered line from somebody nobody draws is a line. In a comic script,
    1. PHONE (OP): Ring. was read as prose, without a word, though PHONE (OP): Ring. is a
    line: a lettering item's number was set aside only before a cast member's cue. Somebody heard
    from off panel or in voice over need not be cast, numbered or not.

  • A line indented to match no line above it is said to be (#261). PyYAML calls it
    "expected ", which says nothing of the space too many or too few behind it;
    the message now says how far in the line is, and how far in the line it likely goes with
    is: deleting the # of a gallery example's try-this line and leaving its space, say.

  • A syntax error in a comic script's front matter is located (#261): rule syntax, on its
    line of the file, where it was rule invalid-field on line 1, with line numbers counted
    from the front matter's first line.

  • The how-to on debugging a layout named two of the compiler's notes; there are eight,
    now each in a table with what to do about it.

  • The scene schema accepts a null wherever settle applies one (#239): camera: null on
    a panel of figures over one with a camera, as the docs teach, was underlined in an editor and
    compiled. Any key a scene reaches through mappings may now be null; a list entry is still
    whole. The panel schema is unchanged.

  • A member left out with null keeps the look at them while heard from off panel (#258).
    cast: {carol: null} dropped the panel's own bob looking_at carol, with a
    dropped-relation note, even while Carol spoke off_panel there, and her off_panel: true
    ended on the side nearer her balloon. As with a comic script's CAROL (OP), Bob now turns
    toward her side and her line ends on the side she was written to stand on; every other
    relation that names her still goes. In a script, @cast: {CAROL: null} beside CAROL (OP)
    is no longer refused as drawing her.

  • The contributor documents say what CI does (#324). CONTRIBUTING.md lists every gate
    CI runs, basedpyright and the documentation build included, installs every dependency
    group, says what to regenerate when the output moves, and asks for the commit titles the
    history actually has rather than Conventional Commits; it and the maintainer guide link each
    other. Both, with CLAUDE.md and the design decisions, say to quote forward references,
    since the 3.12 floor needs it: two of them said the opposite. The design decisions call
    basedpyright blocking, as ci.yml has made it, and gain the section on the floor the
    install guide links. The maintainer guide has a row for every check a pull request runs.
    SECURITY.md says alpha, names the release that gets fixes, and covers what Scenet really
    reads and serves: scenet mcp over HTTP, fonts, pictures, artwork contracts, puppet files and
    paths that climb out with ... The pull request template asks for a CHANGELOG line and lists
    every generator; the bug report takes a scene, a comic script and the files a document names.
    Every kind in this file is one heading per release, and tests hold all of it to the
    repository.

Install

pip install scenet==0.13.0

The VS Code extension is the attached scenet.vsix:
Extensions -> ... -> Install from VSIX...

Documentation |
Playground