Skip to content

Releases

v0.13.0

Choose a tag to compare

@github-actions github-actions released this 12 Nov 09:34
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
    li...

Read more

v0.12.0

Choose a tag to compare

@github-actions github-actions released this 29 Oct 20:01
6927378

Upgrading from 0.11.1.

  • A font path written with \ between folders is refused, on Windows as everywhere else:
    write /. So is one holding a control character, which used to crash build and check.
  • conflicting-setting covers a picture too: an image beside a place, masses or a
    horizon. Its SARIF description and help say so; a place beside masses is reported exactly
    as before. A panel that inherits a place and names an image is refused the same way; it
    writes place: null beside the image.
  • A comic script's prose is now read, as its panel's description. A line of it holding a
    control character an SVG cannot hold, which used to pass unnoticed, is reported at that
    line as invalid-field. description in a script's front matter is refused.
  • Every Panel Core gains description, and each balloon, caption and sound effect a
    label.
    Nothing else in it moves, and format_version stays 1: a Core without them is
    still valid and writes back byte for byte, but golden Core files of your own will need
    regenerating once. 0.11 refuses the new keys.
  • Every Panel Core gains camera; each actor joints, features and, when it looks at
    somebody, looking_at; a backdrop of masses time and, for a named place, place
    (#72).
    Nothing else in it moves, no SVG changes, and format_version stays 1: a Core without them is
    still valid and writes back byte for byte, but golden Core files of your own will need
    regenerating once. Every gallery Core was compared with its 0.11.1 golden and differs by these
    keys alone. A panel whose cast a picture draws has no camera, and 0.11 refuses the new keys.
  • A balloon over its own speaker's body costs what it always should have when the actor id
    is not the puppet's name (ALICE: {reference: alice}, carol: {reference: alice}). Such a
    speaker was charged as a bystander, so balloons drifted away from them. Three gallery
    panels letter differently, each balloon now beside its speaker: regenerate golden Cores of
    your own that cast an actor under another name.
  • CaptionEvent.prefer is None when it was not written, where it used to read top_left:
    an unwritten zone is where reading starts, which the solver decides from direction. A caption
    is placed exactly where it was. Code reading it from the Python API takes None as top_left
    for a left-to-right panel.
  • CastMember.reference may be None, for a member that is a figure a picture draws, and
    CompileResult.camera is None for a panel whose cast is all figures. Code reading either
    from the Python API narrows them first; PanelIR.puppets() gives every puppet's reference.
    A member that names neither a puppet nor a figure is reported exactly as before.
  • Every SVG's bytes change once, to carry what a screen reader reads: a role and a <title>
    per panel, and aria-hidden on a page's own shapes. Nothing is drawn
    differently and lettering stays outlines. --no-aria (aria=False) gives back exactly the
    SVG written before, for a pipeline that post-processes it; debug overlays are unchanged.

Added

  • Export a panel's staging for image models (#72): scenet build --conditioning writes five
    files beside each panel's SVG — the pose as OpenPose COCO-18 JSON, a phrase and a box per
    figure as GLIGEN takes them, a depth map (stepped grey planes in painter's order, white near),
    an instance mask under the panel's own ids, where a character keeps its colour across panels
    unless another in the same panel has the same hue, and the semantics: camera, setting, cast
    with each character's mask colour, and lettering, as structure and never as a prompt. No model runs in Scenet: each is one more
    emitter reading Panel Core, text, JSON or SVG, byte-identical like the rest, and nothing is
    rasterised. The pose names left and right as OpenPose does, by the subject's side; a point
    outside the panel, an ear, or a joint a puppet does not name is 0, 0, 0. Figures a picture
    draws have boxes and masks and no pose; a picture is the far plane; a panel read right to left
    exports the same pose, boxes, depth and mask. render_conditioning and Conditioning join
    scenet.__all__; MCP render takes conditioning (still five tools); the playground offers
    the five downloads for a one-panel document. See the how-to, "Export a panel's staging for
    image models".
  • direction: ltr | rtl, which way a comic is read (#68): rtl for manga, read from the
    top right. It is the comic's progression, not its text's, and EPUB's word for it. Written once
    for the whole document — at the top of a panel, beside panels:, or in a comic script's front
    matter — and inherited by every panel; a panel's own, and a script's @direction:, are the new
    rule panel-direction. The editor's schema offers it. Panel Core and Page Core record it when it
    is rtl; a left-to-right Core is byte-identical and format_version stays 1.
  • A panel read right to left is lettered from the top right. A balloon or caption may never sit
    above and right of one before it; a caption with no prefer, and a voice from off panel with no
    side named, start top right; every tiebreak between equal placements is mirrored, so the mirror
    image of a panel is lettered as the exact mirror of the original; and a generated description
    names the cast from the right. Nothing in the picture moves: figures, gaze, tails and sound
    effects are byte-identical, and prefer:, at: and named sides keep meaning places on the panel.
    The debug overlay says "read right to left".
  • Pages and strips read right to left. Under direction: rtl a tier's first panel, or first
    column, is at its right; each frame is the one the tier reversed would have, so every panel
    keeps its size and its art, an inset keeps its corner and a slant leans as written. The pages of
    a document side by side (render_pages, the playground) and a strip start at the right, and every
    one is still written in reading order. A strip or a row of pages read two ways is refused.
  • Two gallery pages, the same manga page read right to left and left to right.
  • setting: {image: ..., fit: cover | contain}: a picture drawn elsewhere, behind the
    cast (#70). It is a backdrop of its own, so it is written instead of a place or
    masses, never beside them or beside a horizon (conflicting-setting); a fit with
    no image is invalid-field. A panel that inherits a place writes place: null beside
    its image, and the editor's schema now accepts that null.
  • The picture is read from its PNG or JPEG header, beside the document as a font is, and
    only its size is taken. scenet check reports a picture that is absolute, missing, not a PNG
    or JPEG, or turned by its EXIF orientation as the new rule image-file, without the solver.
    Text compiled with no folder may be handed the files it names instead: base takes a
    mapping from the path the document writes to the file's bytes, for fonts as for pictures.
  • The picture is placed, and Panel Core records it. Centred, filling the panel (cover)
    or shown whole inside it (contain), never stretched. backdrop.image holds the path as
    written, the media type, a digest of the bytes, the pixel size, the fit in SVG's words and
    the rectangle it is drawn in; over a picture backdrop.horizon is left out. A Core of masses
    is byte-identical, and format_version stays 1. The picture costs a balloon nothing and does
    not move the camera, and a generated description names no place and no hour over it — only
    the weather drawn on top.
  • The picture is drawn, as an <image> on the paper, under every figure and the weather,
    in the rectangle Panel Core placed it in. It is linked by xlink:href — Inkscape does not
    load plain href — to the path exactly as written, which resolves when the SVG is beside
    the document; scenet build --embed-images (embed= on every renderer) writes its bytes in
    as a data: URI instead, and build says so in a note when a link will not resolve. The
    debug overlay shows where it was placed. A new how-to, Letter over your own art, and a
    gallery example drawn over a picture the repository paints itself, under its own licence.
  • The MCP server's validate, compile and render take files: the files a document
    names, by the path it writes, as base64. They stand in for the document's folder, read in
    memory, so a model can letter over a picture — or in a font — it sends; render embeds
    the picture. Still five tools.
  • The playground's Image… button adds a .png or .jpg to the document's art/ folder,
    for as long as the tab is open, and the preview and every download embed it. The VS Code
    preview embeds pictures too, since it is not drawn beside the document.
  • An artwork contract declares the figures a supplied picture draws (#71): beside
    art/p01.png, art/p01.art.yaml gives each figure's face (a disc lettering may not
    cover), mouth (where a tail ends) and body, and keep_out regions lettering should stay
    off, all in the picture's own pixels, with the size they were measured on.
    scenet schema --artwork emits its JSON Schema, which the VS Code extension associates with
    *.art.yaml and the documentation site publishes beside the others. Panel Core records what a
    contract declares, mapped into the panel through the picture's fit: figures, beside
    actors, and the picture's keep_out. Both are left out when empty, so every Core reads and
    writes as before and format_version stays 1; the debug overlay draws each figure's face,
    mouth and body, and each keep-out.
  • Figures a picture draws, in the cast (#71): cast: {ana: {figure: ana}} in place of
    reference:. The panel's picture's artwork contract says where each face, mouth and body is,
    and lettering is placed by the same rules as around a puppet...
Read more

v0.11.1

Choose a tag to compare

@github-actions github-actions released this 18 Oct 12:20
17f21b5

The documentation site documents the release you install, and shows off its playground;
and two comic-script fixes.
The site's root now serves the latest release, main moves under
/dev/, and each minor version keeps its own path; the playground says which version it runs,
and the home page shows its example compiled, with a button to open it there. A full stop
now ends a PAGE heading, and no line of a comic script can stall the compiler.

Upgrading from 0.11.0. The language, the command line and the Python API are unchanged,
and so is every YAML document's output. A comic script changes only where a PAGE heading
ends in a full stop, as in PAGE 7. or PAGE TWENTY ONE.: see Fixed.

Added

  • The documentation site documents what you install. Its root, and every address
    already in use there — the documentation, the playground, schemas/panel.schema.json,
    scenet-spec.md, llms.txt — now serves the latest release, not unreleased main.
    main moves to /dev/, and each minor version
    from 0.8 stays online under its own path, such as
    /v0.10/, its playground running that
    release's compiler. A version switcher in the navbar keeps the page you are on. /dev/ and
    older versions carry a banner linking to the same page in the latest. Pin a schema or the
    spec pack to a release by putting its version in the path:
    …/scenet/v0.11/schemas/panel.schema.json (#171).
  • Each release attaches its built site as scenet-X.Y.Z-site.zip, built from the wheel
    it publishes, before PyPI. The site serves every version from these, unchanged. Releases
    0.8.0 to 0.11.0 have theirs backfilled.
  • The playground says which version it runs, with the same version switcher as the
    documentation, keeping a shared document across the switch. On main's and on an old
    release's it says so, with a link to the latest. Playgrounds built before this change,
    those of 0.11.0 and earlier, carry no switcher.
  • The documentation's home page shows its example compiled — the file scenet build
    writes for it, kept current with the golden files — and a button opens that example in the
    playground. The navbar names the playground beside the sections, and every link to it
    opens the playground of the version being read.
  • Dependencies and code are watched by GitHub's own security tooling. Dependabot alerts
    and security updates cover the dependency graph, which GitHub builds from uv.lock and both
    package-lock.json files, transitive dependencies included. A pull request adding a
    dependency with a high or critical vulnerability fails dependency review. CodeQL analyses
    the Python, the TypeScript and the workflows on every pull request, on main and weekly.
    Secret scanning rejects a push that contains a credential. See SECURITY.md.

Changed

  • Every pull request checks the package as a release would. CI's new Package job builds
    the sdist and the wheel, runs twine check --strict on them, smoke-tests the wheel from an
    empty directory, and builds the wheel again from the sdist alone, comparing the two. The
    smoke test is now one script, scripts/smoke_wheel.py, that the release runs too.
    Nothing is published: TestPyPI stays a manual rehearsal.

Fixed

  • A full stop ends a PAGE heading, as it ends a PANEL one. Page 4B. named its page
    4B. and PAGE 7. a page called 7.; PAGE TWENTY ONE. and PLANCHE 3. were not
    read as headings at all, since ONE. and 3. are not numbers, so their panels ran on
    into the page before. They are pages 4B, 7, 21 and 3 now. A full stop inside a
    label, as in PAGE 3.5, stays.

Security

  • A comic script cannot stall the compiler with one crafted line. The PAGE heading
    pattern backtracked exponentially on a line like PAGE !-!-!-…(: fifty characters took
    seconds, and each two more took four times as long. Found by CodeQL, which led to the
    rest: the PAGE, SFX, caption and cue-with-its-line patterns each let two parts take the
    same run of space, so a long gap was quadratic or cubic -- a caption line of sixty
    thousand tabs took twenty seconds, an SFX line with a note three minutes. Every line
    is now read in time linear in its length, so scenet build, scenet check (which the
    editor runs on open and save), the MCP server and the playground cannot be hung by a
    script. The patterns read every script as before, with one exception at the edge: in
    PAGE A - . the full stop now ends the heading, as it already did in PAGE A .,
    rather than ending the label.
  • The playground's DOMPurify is 3.4.17, past two advisories affecting versions up to
    3.4.15 (GHSA-6688-9rhm-gjv2, GHSA-p98j-92pf-mc4p). It reaches the playground through
    monaco-editor, which pins an older version, so the override that lifts it is raised by
    hand: Dependabot's security update cannot do it.

Install

pip install scenet==0.11.1

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

Documentation |
Playground

v0.11.0

Choose a tag to compare

@github-actions github-actions released this 17 Oct 17:27
37db9c6

Lettering, sound effects, and comic scripts as publishers write them. A stressed word is
lettered in bold italic, every pair is kerned, the type size can be set, and an author can
letter in their own face. Sound effects are lettered into the picture in a display face. A comic
script may be written as Dark Horse publishes its format, or in French, with captions that carry
speech, voices from off panel, small type, and its PAGE headings laid out as pages; scenet check gains notes, the first of them a publisher's word limits.

Upgrading from 0.10.

  • Every example's lettering shifts slightly. Kerning makes most balloons and captions up to
    about 1.5% narrower, and where two positions had scored nearly equal a balloon may sit
    somewhere else. Golden files of your own will need regenerating once.
  • A few comic-script lines mean something new, each listed under Changed: prose before the
    first heading is a title page, PANEL ONE is panel 1, Panel 1. A description. is a
    heading, an all-caps NAME: text with NAME in the cast is dialogue, a bare CAPTION starts a
    caption, and CAP, CAPTION and SFX are reserved.
  • A comic script with PAGE headings now writes its pages, and the panels on them are
    compiled at the size of their frames and lettered at the page's one size, so they look
    different; the front matter's panel: {size} now sizes only panels on no page.
  • scenet check can print notes -- file:line:column: note: rule: message -- and exits 0
    when there are only notes. The MCP server's findings gain level, and validate calls a
    document with only notes valid.

Added

  • scenet check reports notes as well as errors. A note is a house limit rather than a
    contradiction: the document still builds, so a note never fails the check. The first is
    Dark Horse's word limit, word-limit: a balloon or caption over about 25 words, or a
    panel over about 50, in YAML and in comic scripts alike. Words are counted as lettered,
    so -- and emphasis underscores add none, and sound effects are not counted.

    • In text, a note reads file:line:column: note: rule: message; an error's line is
      unchanged.
    • In SARIF, the level comes from the rule, in defaultConfiguration and in each result,
      so VS Code and the playground show a note as information.
    • check exits 1 only on an error, and prints ok for a document with only notes.
    • The MCP server's findings gain level, and validate calls a document valid when
      none is an error. (Part of #75)
  • Comic scripts in Dark Horse's published layout compile. PAGE ONE (five panels) is a
    page heading whose count is checked against the panels under it, as the new
    panel-count note. Panel 1. Alice and Bob on a corner. is a panel heading with its
    description on the same line, and Panel One is panel 1. A title page — the writer's
    name and address — may come before the first heading. Markdown's ## PANEL 2,
    **PANEL 2** and horizontal rules are read as the headings and blank lines they mark.
    A cue with nothing said under it, and a name in capitals with a line under it on the
    title page, are looks-like-dialogue notes. scenet build prints these notes, and
    Book.notes carries them. (Part of #75)

  • Comic scripts read Dark Horse's lettering labels. CAP: and CAPTION take their
    text from the line or the lines under them; Dark Horse's CAP/ALICE is a spoken
    caption by Alice, with the writer's quotation marks taken off so they are not doubled;
    ALICE (V.O.) is a voice over, lettered as a spoken caption. ALICE: Hello. is
    dialogue when Alice is in the panel's cast, and a looks-like-dialogue note otherwise.
    (burst) is a shout, several parentheticals are read together, and Blambot's numbered
    items, 1. ALICE:, are read with their number set aside. (Part of #75)

  • @over: in comic scripts writes a panel as a change to another, with the merge
    rules over: has in YAML: the panel inherits the other's directives, never its
    dialogue. @over: 1 names panel 1 on the same page first, then the panel named 1. A
    missing panel, a cycle or a panel over itself is one composition finding at the
    @over: line. (Part of #75)

  • Off-panel speech. say: {by: caller, text: "Open up!", off_panel: left} is spoken by
    somebody nobody draws: the balloon's tail ends on the frame, on that side, or on the
    slanted outline of a slanted panel. off_panel: true lets the compiler take the nearer of
    left and right. The speaker is not in the cast, and one who is drawn cannot speak from off
    panel: the new error off-panel-speaker. Panel Core balloons gain off_panel, the side,
    written only when set, so no existing Core changes. (Part of #75)

  • ALICE (OP) in a comic script is off-panel speech, as are (OFF), (O.S.) and
    (O.C.). Alice is left out of that panel's cast and of the staging that names her, each
    relation with a dropped-relation note, and her tail ends on the frame on the side she
    was written to stand, unless the cue names one, (OP, right). A cue for somebody never
    cast, PHONE (OP), works too. (Part of #75)

  • Small lettering. say: {..., size: small} letters a line at three quarters of the
    dialogue size, in a balloon padded as the normal size would be: muttered, as Blambot
    describes it. A comic script's (small) and (weak) give it. (Part of #75)

  • French comic scripts. PLANCHE 1 (six cases), CASE 2 and VIGNETTE 2 are headings;
    RÉCITATIF, CARTOUCHE and NARRATIF are captions; ONOMATOPÉE is a sound effect;
    LÉA : « Bonjour. » is a cue and its line, with a no-break space before the colon. (pensée)
    is a thought, (off) and (hors champ) off-panel speech. @shot: and @angle: take the
    échelle des plans — gros plan is big_close_up, plan rapproché épaule is close_up —
    and plongée, contre-plongée. Both highlighters follow, and the gallery gains
    33-planche.script. (Part of #75)

  • A figure may look at somebody heard from off panel: bob looking_at carol, where Carol
    speaks off_panel: left, turns Bob toward the left of the frame and aims his eyes out of it.
    With no side named, Carol is heard from the side Bob faces. In a comic script,
    BOB looking_at ALICE now survives ALICE (OP) instead of being dropped with a note.
    (Part of #75)

  • null leaves an inherited cast member out of a panel: cast: {bob: null} in a scene's
    panel, under over: or over the scene's defaults, or @cast: {BOB: null} in a script. It
    follows JSON Merge Patch (RFC 7386), "If the value is null, remove". The staging relations
    that name him go too, each a dropped-relation note, and the JSON Schema accepts the null.
    (Part of #75)

  • French delivery words, from the BnF's sheet on balloons: (murmure) and (chuchoté) are
    a whisper, (cri) and (crié) a shout, (à voix basse) small type. (Part of #75)

  • compile_script compiles a comic script handed over as text, exactly as scenet build compiles a .script file. scenet check --deep, the MCP server and the
    playground now all go through it, rather than assembling a script each their own way.
    (Part of #75)

  • A stressed word is lettered in bold italic. Write it between underscores, the way a
    script underlines it: I _told_ you. It works in dialogue and captions, in YAML and in
    comic scripts, and the word is measured in bold italic as well as drawn in it, so it
    widens its balloon by exactly as much as it is drawn wider. An underscore inside a word
    stays an underscore, and \_ writes one anywhere. Emphasis that is opened and never
    closed is reported as unbalanced-emphasis, and a value starting with *, which YAML
    reads as an alias, now says to quote it. Panel Core gains runs beside lines, written
    only for a line with emphasis, so every existing panel compiles byte for byte as before.
    (Part of #74)

  • The editor guide shows how to see scenet check findings in VS Code today: write them
    as SARIF and open the file with Microsoft's SARIF Viewer. (Part of #77)

  • The VS Code extension shows what scenet check finds, as you open and save a panel,
    scene or comic script: an actor not in the cast, an ordering cycle, a pose the puppet
    lacks, which the schema cannot see. Each finding is underlined where it is and listed
    under Problems with its rule, linked to its explanation, and goes away when it is fixed.
    scenet.checkDeep adds --deep; scenet.checkOnSave turns it off. If scenet cannot
    be run, or crashes, a notification says so once rather than leaving the list empty.
    (Part of #77)

  • The extension is now versioned with the compiler, starting at 0.10.0, so the .vsix on
    a release says which release it belongs to.

  • The VS Code extension highlights comic scripts, as the playground does: headings,
    directives, captions, cues and their parentheticals, dialogue set apart from prose, and
    the front matter as YAML. Both highlighters are tested against one set of fixture
    scripts, which are themselves checked against the compiler's reading, so neither can
    drift from the other or from the format. (Closes #77)

  • Type size can be set: lettering: {size: N} is the dialogue size in panel units,
    and captions keep their proportion to it. Set beside panels: it applies to every
    panel, so a whole page letters at one size you chose; on one panel, to that panel
    alone; in a comic script, in the front matter or an @lettering: directive. Left out,
    nothing changes. (Part of #74)

  • Letter in your own face. lettering: {font: fonts/Comic.ttf}, or a file per face
    under regular, italic and bold_italic, sets the lettering in fonts the document
    names, read relative to the folder it is in -- never a system font, and never an
    absolute path. A face left out stands in from one given, and the compiler says so when
    that matters. Panel Core record...

Read more

v0.10.0

Choose a tag to compare

@github-actions github-actions released this 10 Oct 15:06
a9dfd5c

Pages. A scene can now be laid out on pages -- tiers of panels, columns beside them,
insets set into corners and gutters that lean -- and scenet build writes each page beside
its panels. This release also closes more than twenty ways a document could lose something,
point at the wrong line, or end in a traceback, and the test suite now holds the compiler to
its promises with generated documents, golden outputs on every platform and weekly mutation
testing.

Upgrading from 0.9.

  • Some documents that compiled now refuse, each for a fault that was losing something
    without a word: a key written twice in YAML, a panel named with an unquoted number, .inf
    or .nan anywhere, a control character in a line or an actor id, an inset that does not
    fit its panel, and two outputs that would be the same file.
  • Every panel with lettering renders slightly differently. Glyphs are now drawn at the
    size they were measured, which at some sizes is 14% smaller than before; a strip's ids are
    prefixed by each panel's position; and --strip no longer writes a strip of one panel.
  • Some findings moved: an unknown speaker is at script.N.say.by, a block-style key at
    its own line, a broken over: at the over:. Code that matched on the old paths, the MCP
    server's where included, needs updating.
  • A comic script that numbers its panels per page now names them by page and panel
    (2-1), where before the later page overwrote the earlier one.

Added

  • Pages. A scene can lay its panels out with pages:: each page a list of tiers, each
    tier a list of panels, and a weight for each tier's height and each panel's width, shared
    out of what page:'s margin and gutters leave, the way CSS Grid shares a row. A panel on a
    page is compiled at its frame's size and nothing else changes about it, except that every
    panel on a page letters at one type size. (#66)

    • scenet build writes each page as stem.page-<n>.svg, with its Page Core and overlay
      under --core and --debug, and refuses a panel whose file would be a page's.
    • A new tier, Page Core, records where every frame is and the type height the page
      shares. compile_book returns the panels and the pages; render_page and
      render_pages draw them.
    • scenet check reports scenet/page-layout for a placement naming no panel, a panel
      placed twice, or no room left by the margin and gutters.
    • The published schema, the VS Code extension and the playground understand pages; the
      playground shows a document's pages side by side, and its Panel Core view holds the
      Page Cores. MCP compile returns each Page Core and render one SVG per page.
    • A gallery example, a how-to (Compose a page), and a prior-art entry on where the rules
      come from: Cohn's reading-order experiments, Peeters, Groensteen, CSS Grid.
  • Columns on a page: a tall panel beside a stack. A tier can hold columns: in place of
    panels:, each column a stack of panels shared out by height, and a column of one panel
    spans the whole tier. A tier of columns is read down each column before across, as readers
    read a stack blocked by a tall panel. Two stacks side by side block nothing, readers go
    across them, and scenet check refuses them as page-layout. (Part of #67)

  • Insets: a small panel set into a corner of another, drawn over it inside a ring of white.
    insets: on any placed panel takes a corner, a size (a fraction of the parent, at most a
    half) and read: before or after. Readers split about evenly over an inset, so its place
    in the reading order is written, never guessed: after its parent by default. (Part of #67)

    • The parent's art does not move. Its lettering keeps clear of every inset, as firmly as of
      a face, and its Panel Core records what it kept clear of as exclusions. A note says when
      an inset covers a face.
    • Page Core frames gain inset_of and clearance, and the page paints every inset over its
      parent whatever its reading order. Neither new field is written where it is unused, so
      every existing Core is byte-identical.
    • scenet check reports two insets that overlap as page-layout, located at the second.
    • The debug overlay draws what an inset covers. A gallery example, and a section of the
      Compose a page how-to.
  • Slanted tiers: slant on a tier of panels leans every gutter in it, up to 30 degrees
    either way, for a beat that should not sit square. Neighbours share one cut, a gutter stays a
    gutter wide across it, and the tier's outer edges stay upright, so every frame is a convex
    four-sided shape. (Closes #67)

    • A slanted panel is staged in its bounding box and cropped to its outline, which its Panel
      Core and its Page Core frame record; its lettering stays inside the outline, a margin in. A
      note says when the cut runs through a face.
    • A rectangle writes no outline, so every existing Core and page is byte-identical.
    • scenet check refuses, as page-layout, a slant on a tier of columns, on a tier of one
      panel or on panels with insets, and one too steep to leave every panel some width.
  • scenet/duplicate-panel, the finding for two panels in a script that would still share a
    name: PANEL 1 twice on one page, or twice with no PAGE heading between them. It points at
    the heading that repeats. (#63)

  • scenet/duplicate-key, the finding for a key written twice in one YAML mapping. It points
    at the second and names the line of the first. (#83)

  • Golden outputs, checked on every platform. The gallery is built through scenet build
    in every CI job, Windows included, and the bytes on disk must match committed goldens: every
    Panel and Page Core in full, and a digest of every SVG. Two processes with different hash
    seeds, and a relative path against an absolute one, must write the same bytes, and no output
    may hold the path it came from. scripts/update_golden.py regenerates them. (#94)

  • Weekly mutation testing of the solver and the emitters. .github/workflows/mutation.yml
    runs mutmut over solve/ and emit/ every Monday and
    on demand, and reports every small edit to the code that no test notices, with the score in
    the job summary. A second job runs the property tests with fresh random seeds and 300
    examples each. Neither runs on pull requests or blocks a merge. mutmut is in its own
    mutation dependency group, so a plain uv sync does not install it. (#95)

  • The command-line reference is a tested contract. Each command's options, choices,
    defaults and exit statuses, the frontends, and every behavioural sentence in
    docs/reference/cli.md are checked against the code in both directions, so neither can
    drift alone. Every rule has a document in tests/rule_corpus/ that must produce exactly
    one finding of it. And the scenet commands in the documentation's shell examples now run
    in the test suite, as its Python examples already did. (#93)

  • Property-based tests for pages, scripts and broken documents. Generated books are
    held to the documented reading order, worked out from the pages as written, to frames that
    stay inside the margins and clear of each other, and to sound SVG with ids unique across
    pages. Generated comic scripts lose no panel and no line. And a valid document given any
    one mistake from a catalogue of twenty-odd must get exactly one finding from scenet check, under the right rule and on the right line; arbitrary input must never get a
    traceback. The eight bugs they found are fixed above. (#92)

  • Property-based tests. The checks a compiled panel must pass, which ran on five
    hand-written panels, now also run on panels Hypothesis generates: lettering inside the
    margin, off every face and in reading order against every earlier box; an SVG that
    parses, whose ids resolve and whose glyphs are drawn at their measured size; compiles
    that are byte-identical; Panel Core that round-trips; and scenet check --deep agreeing
    with the compiler. The examples are fixed, so a failure replays on every machine.
    docs/maintainer/testing.md explains the profiles and how to add a generator. (#91)

Fixed

  • The same panel could compile to different bytes. kiwisolver, which places the cast,
    keys its internal maps by object address, so the same layout solved twice could come back
    a few ulps apart. A coordinate derived from it that sat on a rounding boundary then
    printed as 247.95 in one compile and 247.96 in the next, in the same process. Solved
    positions are now snapped to a millionth of a unit as they leave the solver, far above
    that noise and far below anything the output shows. One gallery golden moves by 0.01 as a
    result. Found by the weekly Hypothesis exploration. (#117)
  • One mistake in a puppet part was reported six times. A part is a bone (from, to,
    width) or a blob (at, radius), and a bone with a bad width was also tried as a blob,
    so pydantic listed five more errors about a blob nobody wrote, under paths naming its
    classes. A part is now checked only as the kind its keys say it is, at parts.N.bone or
    parts.N.blob, and a part with the keys of both kinds or of neither is one error that
    says what a part must be. The same fix #98 made for script entries. (#92)
  • A font with no character map raised KeyError: 'cmap' from inside fontTools when
    passed as metrics=, instead of the ValueError that FontMetrics documents for a font
    it cannot measure text against. Found while triaging mutation testing. (#95)
  • scenet build could silently overwrite one output with another. Only a panel named
    like a page was refused. A panel named strip replaced the strip, x.debug replaced panel
    x's overlay, and two names differing only in case wrote one file on Windows and macOS.
    Every output is now planned before anything is written, and two ...
Read more

v0.9.0

Choose a tag to compare

@github-actions github-actions released this 03 Oct 00:07
7e3dc04

A release for maintainers: Scenet can now be listed in the MCP registry from a workflow. The
language, the compiler and the scenet mcp server are unchanged from 0.8.0.

Added

  • A workflow lists releases in the MCP registry. mcp-publisher login github cannot publish
    under an organisation namespace, because the registry's GitHub App is not installed on the
    organisation and io.github.creatoan/* answers 403 whatever the role. The new
    .github/workflows/registry.yml logs in with the workflow's OIDC token instead, which proves the
    namespace through the repository and needs no secret. Run it by hand for an existing tag, or set
    the repository variable MCP_REGISTRY_PUBLISH to have release.yml call it after each release.
    It checks that server.json names the tag's version and that the version is on PyPI before it
    publishes, and pins mcp-publisher to a version and a SHA-256. (#60)

Fixed

  • The release guide advised mcp-publisher publish --dry-run, which publishes. publish has no
    such flag, so an unknown one is ignored and the listing happens. The guide now says to use
    validate, which checks the manifest against the live registry and changes nothing. (#60)

Install

pip install scenet==0.9.0

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

Documentation |
Playground

v0.8.0

Choose a tag to compare

@github-actions github-actions released this 02 Oct 23:18
0402bb3

Models can now be told how to write Scenet, and can check what they wrote: a spec pack, an
Agent Skill and an MCP server. A comic's marks — sweat, dizziness, oaths, dust — join the
language, and diagnostics in comic scripts and shared casts now point at the right line.

Added

  • Emanata: what a comic draws around a character. A cast member takes marks:, a list
    from Mort Walker's Lexicon of Comicana: plewds (sweat flying off the head), squeans
    (dizziness), grawlixes (an oath, as a spiral, a star, a bolt and a hash) and briffits
    (the dust of a hasty exit). A list rather than a second expression:, because they compose
    — a character can be angry and sweating. Every puppet gets every mark; nothing new is
    declared per puppet. At long_shot each mark collapses to a dot, and a figure too small to
    have a face has none. (#21)
  • Marks cost a balloon space, and never move anybody. They are drawn outside the head,
    where balloons go, so each mark has a zone that balloons and captions pay to cover —
    weighted above covering a body, with no discount for the speaker. They stay out of the
    hull, so staging, the camera and every figure are exactly where they would be without them,
    and a crowded panel still compiles. The camera makes no room for them either, so a mark
    cropped by a tight shot is reported in the compile notes. The debug overlay draws the zones.
  • scripts/contact_sheet.py --marks renders every mark across the shot ladder, and the
    gallery gains 23-emanata.scene.yaml.
  • A way to tell a model how to write Scenet. The spec pack puts the language
    reference, the shot types, the comic-script format, the shipped characters, every
    diagnostic rule, the JSON Schema and the whole gallery in one file, published at
    /scenet-spec.md beside an
    llms.txt. It is what to hand a chat app
    that cannot run code, such as NotebookLM, which can then write a comic script for you to
    compile. skills/scenet is
    an Agent Skill for coding agents. All of it is generated from
    the compiler's own sources, and a test fails if a committed copy goes stale. (#11)
  • scenet mcp, an MCP server, so a model can validate its own panel, read findings
    that name the rule, the line and the fix, and render the result with nobody relaying
    errors. Five read-only tools — get_spec, list_puppets, validate, compile,
    render — over stdio or Streamable HTTP, on protocol revision 2026-07-28. It needs the
    new optional extra: pip install 'scenet[mcp]'. A server.json describes it for the
    official MCP registry. (#11)
  • Driving Scenet from a model,
    a how-to for each kind of client, and two entries in prior art: WordsEye, the ancestor of
    text-to-scene, and Gumin et al. 2025, the strongest argument against a declarative
    language, recorded for what it actually found. (#11)

Changed

  • Panel Core actors gain marks, emanata and emanata_zones. All default to empty, so
    format_version stays 1 and a Core document written before them still reads. Every actor
    now serialises the three keys, so a golden file captured against 0.7.0 will differ by them
    — and by nothing else: every example in the repository lays out byte-identically.

Fixed

  • A comic script's line numbers counted from the end of its front matter, not from the
    top of the file, so scenet check and the playground pointed several lines above the
    fault in any script with a cast block — which is nearly all of them.
  • A panel in a comic script that failed validation — a misspelled @shot:, say — was
    reported at line 1 whichever panel it was. It is now reported at that panel's PANEL
    heading.
  • A bad name in a shared cast was reported once per panel, every copy pointing at the
    panel rather than at the line that was wrong — in a comic script's front matter, all
    of them at line 1. A fault in a scene's defaults or a script's front matter is now
    reported once, where it is written. A panel's own mistakes still carry its name.
  • scenet build printed a traceback for a file with an unsupported extension, and
    scenet check called the same file ok. Both now report it as a usage error, exit 2.
  • scenet build foo.panel.yml wrote foo.panel.yml.svg. .yml is now named
    exactly as .yaml is: foo.svg.
  • The command-line reference's scenet check examples/gallery/*.yaml examples failed,
    because the glob also matched the gallery's manifest. CI's gallery check now includes
    the gallery's comic script, which it had skipped.

Install

pip install scenet==0.8.0

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

Documentation |
Playground

v0.7.0

Choose a tag to compare

@github-actions github-actions released this 01 Oct 22:19
86ce10e

The playground became a place to work, the editor schema stopped rejecting valid
documents, and the project moved to the creatoan organisation.

Added

  • The playground became a place to work, not just a demo. The output zooms and pans —
    scroll or pinch about the pointer, drag, double-click for Fit or 100%, + - 0 1 and
    the arrows — and keeps the zoom while you edit. Download saves the panel as SVG or a
    2× PNG, the overlay, the Panel Core and the source, named as scenet build names them;
    Ctrl+S saves the source. Edits survive a reload, and Share copies a link that
    carries the whole document in its fragment, so no server is involved. A failed compile
    is reported by the same checker scenet check runs: each finding is a squiggle on its
    own line, and the list under the output jumps to it. Actors, staging relations and
    script verbs are coloured; Panel Core opens in a read-only editor with folding; the
    split between the panes can be dragged; the output can go full screen. The editor also
    shows the example at once instead of sitting empty while Python boots. (#45)
  • render_strip(..., debug=True) lays out each panel's overlay where the strip puts the
    panel, so a scene has an overlay too. (#44)

Changed

  • The project moved to creatoan/scenet.
    GitHub redirects the repository, its issues and pull requests, and git remotes. The
    documentation and playground are now at
    creatoan.github.io/scenet; the old
    azias.github.io/scenet addresses do not redirect
    , because GitHub Pages never does.
    If a YAML document names the schema, update its first line to:

    # yaml-language-server: $schema=https://creatoan.github.io/scenet/schemas/panel.schema.json

Fixed

  • The published JSON Schema rejected the syntax people write. It described the IR,
    after the frontend has rewritten staging sentences, - say: wrappers, place: and
    partial scene overrides away — so 21 of the 22 gallery documents failed it, and the
    playground and the VS Code extension underlined lines that compiled. The new
    scenet.schema module puts each of those back; a test now validates every shipped
    example against the shipped schema. (#44)
  • The overlay wrote actor ids into SVG unescaped, in an id attribute and in text
    labels. The playground puts that SVG into the page, so an actor id could close its
    attribute and add markup. Identifiers are now escaped as they already were in the
    panel itself. (#44)
  • scenet check reported a bad staging sentence or script entry against the whole
    document.
    It now points at the entry — an unknown predicate, a malformed sentence,
    an unknown verb. (#44)

Install

pip install scenet==0.7.0

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

Documentation |
Playground

v0.6.0

Choose a tag to compare

@github-actions github-actions released this 27 Aug 20:46
1a487e9

Setting: a panel can now show where and when it happens — and a caption box can be
tinted to read against it.

Added

  • The setting layer: a panel can show where and when it happens. Every panel rendered
    figures on white; there was no setting block at all. Captions (0.4.0) shipped the
    cheap half of establishing place — a locale box can say MIDNIGHT. THE DOCKS. —
    and this is the expensive half.

    setting:
      place: docks
      horizon: mid
      time: night
      weather: rain
  • Backdrops are described tonal masses, never drawn geometry. Crisp architecture needs
    a vanishing point and this is deliberately a flat, orthographic compiler, so drawn
    buildings would fight the compiler's own model — soft masses have no perspective to get
    wrong. It is also how comics actually establish place: notan (Dow, Composition,
    1899) says place is read from the arrangement of masses rather than from rendered
    detail, and aerial perspective supplies the parametric rule — with distance, value
    contrast drops toward the atmosphere.

  • Twelve mass kinds, from COCO-Stuff supercategories — building, ground, plant,
    sky, solid, structural, water outdoors, ceiling, floor, furniture, wall,
    window indoors. Taken from an existing taxonomy of stuff rather than invented, for
    the same reason the predicates came from Visual Genome. Not its leaf names: the real
    classes are building-other and sky-other, and nobody should have to type that.

  • Ten named places — alley, desert, docks, field, forest, mountain,
    office, room, shore, street — each expanding into a mass list the author could
    have written themselves. That rule is what keeps a preset a library rather than a second
    opaque format, and it is enforced by a test. The expansion happens in the frontend, so
    the IR has no place field at all — the same treatment alice left_of bob gets.

  • plane reuses the existing painter's order rather than introducing a second one.
    The three backdrop planes take negative depths; foreground takes one above the
    frontmost actor, so a foreground mass draws over the cast the way a silhouetted doorway
    does. Value follows from the plane and from nothing else, which is what keeps the notan
    reading literal.

  • time and weather. time supplies the two ends of the value ladder rather than
    tinting a daytime panel, so night is a darker, narrower ladder — and the ladder stays
    monotonic in depth at every hour by construction. weather adds fog as a
    feTurbulence veil, and rain and snow as that veil plus falling marks.

  • CoreBackdrop on Panel Core, carrying fully resolved numeric polygons and tone
    values — the same discipline as capsules, blobs and face_marks, so the emitter
    still makes no layout decision. Absent on a panel that says nothing about where it is,
    which is why this needed no format_version bump.

  • Masses are a soft cost for balloon placement, never an exclusion. Balloons sit over
    backgrounds routinely; that is what a background is for. Covering one costs an order of
    magnitude less than covering a face, weighted so a foreground silhouette costs more than
    empty sky.

  • scenet check reports unknown-place and conflicting-setting, each naming the
    field. A place and a mass list together is rejected rather than guessed at: a place is
    a mass list.

  • scripts/setting_sheet.py, the calibration instrument — every place against every
    hour on one sheet, every weather on another. Whether three greys read as depth is not a
    question a test can answer, and four things moved because of what the first sheet showed.

  • Gallery examples 19, 20 and 21, and a docs/reference/language.md section for the block.

  • Caption boxes can be tinted. Captions shipped in 0.4.0 with four kinds and the
    typography that goes with them, and one value: #ffffff, hardcoded in the emitter. A
    tone key now chooses from a three-value palette.

    - caption: {text: "Noon. Nothing for miles.", kind: locale, tone: ink}

    The failing case is the pale end, not the dark one. A caption box is opaque, so its
    lettering was never at risk — the text sits on the fill whatever is behind it. The
    box is what stops reading: against the ladder above, a white box on a noon sky is
    1.16:1, and only the stroke separates it at all.

  • The palette is rungs of the backdrop's own value ladder — paper #ffffff, pale
    #adadad, ink #090909, the last two taken from the day row by index rather than
    restated, so lettering and backdrop cannot drift apart as either is tuned. paper is
    the default, so no existing panel moves. No free-form fill:, and no yellow: an open
    colour field would be this language's one open vocabulary, and the classic yellow
    locale box would be the first non-neutral value in the codebase.

  • ink inverts the lettering to paper — reversed type — chosen by contrast in the
    solver and carried on CoreCaption as fill and ink. The same rule and the same
    reason as falling rain, and it leaves the emitter with no decision about which mark
    reads. Both fields are defaulted, so a Core document written before this still parses
    and no format_version bump was needed.

  • The lettering floor is enforced rather than asserted. contrast_ratio in
    solve/backdrop.py measures WCAG relative luminance — the ladder is spaced in OKLab
    because that predicts even perceived steps, but legibility is checked against the
    published threshold. Every tone clears 4.5:1 against its own lettering, and every rung
    of every hour has at least one tone above 3:1 to sit on. This is the one visual rule in
    the compiler with an objective answer, so it is a test rather than a taste.

  • Gallery example 22, a tone row and section in docs/reference/language.md, and
    fill / ink in docs/reference/panel_core.md.

  • scenet check --deep. Runs the full compiler on any document that passes the
    cheap checks, to additionally catch layout and balloon-placement failures — the
    two rules in the catalogue that were in the catalogue but unreachable from check.
    Off by default: it costs a real compile, including font metrics, and check stays
    the cheap pass it is documented as unless asked otherwise.

Changed

  • long_shot reframes noticeably wider, and wide with it — headroom 0.14 → 0.28,
    footroom 0.06 → 0.10. solve/camera.py admitted the problem in a comment: with no
    environment to show, long_shot and full_shot crop at the same landmark and could
    differ only by a little headroom, so two rungs at the widest end of the ladder stayed
    degenerate. There is an environment now, so a long shot can mean what it says — the
    figure fills roughly two thirds of what a full shot does. Every existing panel that
    asks for long_shot or wide renders smaller than it did.
    The comment is gone and
    docs/reference/shot_types.md is updated.

  • PanelSyntaxError carries an optional rule and loc, so a check the frontend
    performs itself can name a catalogue rule and a field instead of arriving as a generic
    invalid-field. Both default to nothing, so every existing raise is unchanged.

  • The determinism boundary is written down in docs/reference/language.md: the
    contract is on the emitted SVG text, which stays byte-identical, and has never been on
    pixels. feTurbulence is reproducible by specification and browsers still agree only
    approximately on what to paint from it. Stated now, while adding the first feature that
    depends on it, rather than left for somebody to rediscover when a screenshot test flakes.

  • docs/explanation/prior_art.md: shape grammars move from future to load-bearing,
    with the finding that no open-source Python CGA implementation exists — the reference one
    is commercial, inside Esri CityEngine — so the formalism is reused rather than a library.
    Notan, aerial perspective and COCO-Stuff are added as load-bearing; physically based sky
    models (Preetham, Hosek-Wilkie) are recorded as examined and rejected, since they solve a
    radiometric problem this compiler does not have.

  • PuppetSpec.pose_angles and .expression_states raise UnknownPoseError and
    UnknownExpressionError
    on a name the puppet does not declare, rather than a bare
    KeyError. Both are also KeyError — following the precedent UnknownPuppetError
    already set — so except KeyError and the documented Raises: KeyError on both
    methods keep working unchanged.

Fixed

  • extreme_close_up framed the forehead, not the eyes. Its crop landmark (eyes)
    sits inside the face rather than at its edge, and the anchoring rule bottom-anchors
    every crop line — which put the eyes exactly on the panel's bottom edge and the rest
    of the eye region, and the whole face centre, below it. extreme_close_up now
    carries footroom: 0.45, the only lever that can move a crop line off the bottom
    edge; headroom cannot, because it shifts the figure down and shrinks it by exactly
    the same amount. docs/reference/shot_types.md explains why in the Resolution
    section, and the table now shows the footroom instead of —.
  • scenet check said nothing about an unknown pose: or expression:, then scenet build crashed with a bare KeyError. The IR validates syntax and structure
    without knowing the puppet library exists, so pose: smirking passed every check and
    only failed once the solver tried to look it up. check now resolves every cast
    member's reference, pose and expression against the puppet library — reading it
    once per document, only when there is a cast to check — and reports unknown-pose,
    unknown-expression and (newly reachable from check) unknown-puppet, each with a
    ruleId and a location naming the field. This closes the `ch...
Read more

v0.5.0

Choose a tag to compare

@github-actions github-actions released this 26 Aug 17:53
230241f

Faces: a character can now look like something.

Added

  • Faces. A character can now look angry, bored or asleep. expression: on a cast
    member selects one by name, exactly as pose: does — because a face is the same kind
    of thing as a body: a small closed set of arrangements a character can be in.
  • The odd part was that the face was already in the contract and simply never drawn.
    The puppets declared eyes and chin landmarks and eyes/mouth anchors, FaceSpec
    reserved a disc no balloon may cover, and the emitter drew the head as one filled
    circle. This is the rendering that was missing, not new modelling.
  • Ten expressions, and they are a drawing convention. neutral, happy, laughing,
    coy, bored, scared, sad, angry, shouting, surprise — Comic Chat's emotion
    wheel plus surprise, taken from a system that actually rendered faces for live
    conversations rather than from a psychology of emotion. They are the small closed set of
    faces comics draw, not a claim that a person feeling anger produces this face;
    Barrett et al. 2019 is recorded in prior_art.md so that claim is never reintroduced.
  • Feature points, named after MPEG-4 FDP groups — brow, eye, nose, mouth — with a
    mapping to MediaPipe landmark indices in the asset contract. The groups are the reusable
    part; the standard's 66 displacements are a measurement, not a notation. No jaw: the head
    is a circle that does not deform, so a jaw group would have nothing to move.
  • looking_at finally shows on the face. Pupils are aimed at whoever a character is
    looking at, using a vector computed after placement and stored as CoreActor.gaze_aim.
    The existing gaze was the head's forward direction — horizontal for every actor in
    every panel, since no pose rotates the head — so a pupil offset by it would have shown
    nothing that mirroring did not already show.
  • CoreActor.face_marks, as sampled polylines and discs. Curves are sampled during
    compilation, so everything an expression does is a number in Panel Core and the emitter
    keeps making no decisions.
  • scripts/contact_sheet.py renders every expression at every shot type onto one page.
    Whether a furrowed brow reads as anger at fourteen panel units is not a question a test
    can answer, and this is the instrument for answering it by looking.
  • Two gallery examples: ten expressions across a scene, and a big close-up that is the
    first panel in the gallery to show a face at all.

Changed

  • Level of detail. Below a threshold face radius no features are drawn, because five
    of them inside a head a couple of dozen units across stop being a face and become a
    smudge. Panels large enough to show a face are unaffected.

Upgrading

Nothing was removed and no document stops compiling. Two things a caller might notice:

  • CoreActor gained expression, gaze_aim and face_marks. A panel whose puppets
    declare no features compiles exactly as before, but the shipped puppets now declare
    some — so Core output for any panel using alice or bob has changed, and a
    golden file captured against 0.4.0 will differ.
  • scenet.assets.contract gained Feature, FeatureSpec, ExpressionSpec and the
    three state enums. They are puppet-authoring types and are not in scenet.__all__;
    expression: in a document is a plain name, as pose: is.

Known limitations

  • extreme_close_up frames the forehead rather than the eyes. The crop rule anchors a
    shot's landmark at the bottom of the frame, which is right for every rung except the
    tightest, where the landmark sits inside the thing being framed. Correct per
    shot_types.md, which is normative, and newly visible now that there is a face to
    look at.
  • An unknown expression: is not reported by scenet check and fails the build with a
    bare KeyError, exactly as an unknown pose: has always done. Consistency was the
    deliberate choice; the fix belongs to the checker.

Install

pip install scenet==0.5.0

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

Documentation |
Playground