@prestyj/cli 5.28.0 → 5.28.1

package/README.md

@@ -71,7 +71,7 @@ Switch mid-conversation with `/model`. Not locked to anyone.
 | Provider          | Models                                                                       | Auth             |
 | ----------------- | ---------------------------------------------------------------------------- | ---------------- |
 | **Anthropic**     | Claude Fable 5.1, Opus 5.5, Sonnet 5.5, Haiku 4.5                             | OAuth            |
-| **OpenAI**        | GPT-6 Astra, GPT-6 Sol, GPT-6 Luna                                           | OAuth            |
+| **OpenAI**        | GPT-6 Astra, GPT-6.1 Sol, GPT-6 Luna                                         | OAuth            |
 | **Moonshot**      | Kimi K3, Kimi K2.8 Preview, Kimi K2.7 Code                                    | OAuth or API key |
 | **Z.AI (GLM)**    | GLM-5.3, GLM-5.3-Flash (image)                                               | API key          |
 | **MiniMax**       | MiniMax M3 (image + video)                                                   | API key          |
@@ -177,7 +177,7 @@ Plus the [Grep MCP](https://grep.dev) for searching across 1M+ public GitHub rep
 
 `subagent` remains blocking. The async suite launches persistent NDJSON worker processes, so a parent can start up to four active child turns, keep working, steer them, and wait for any or all results. Up to eight idle workers remain available for follow-up; bounded snapshots retain the latest 20 agents.
 
-Only GPT-6 Astra/Sol at **Ultra** delegates proactively. Lower Astra/Sol levels use async agents only when the user or project/skill instructions request delegation; other models receive no proactive policy.
+Only GPT-6 Astra and GPT-6.1 Sol at **Ultra** delegate proactively. Lower Astra/Sol levels use async agents only when the user or project/skill instructions request delegation; other models receive no proactive policy.
 
 Children share the parent working directory by default, so parallel writes must target disjoint files or subsystems. Pass `isolate: true` to `subagent` to give a child its own copy of the repo on a new branch instead — the right choice when several children edit at once, or when a child's changes should land on a branch of their own. The copy is reclaimed automatically when the child finishes without committing; a child that did commit keeps its branch, because that branch is the deliverable. `/integrate` then merges those branches one at a time, running the suite between each. Async fan-out is one level deep, child output is bounded, idle workers reap after 10 minutes, and workers are not resumable after a CLI/app restart.
 

package/assets/motion/THIRD-PARTY.md

@@ -1,10 +1,10 @@
 # Third-party content in EZ Motion
 
-Motion exposes GG-authored support skills and explicitly selected, source-backed
-recipes. The old upstream creative/workflow skills and guidance adapters have
-been removed. Retained technical references are adapted for GG's pinned launcher,
-local-only safety boundaries and recipe-led workflow; do not restore entire
-upstream skill folders when updating the runtime.
+Motion exposes GG-authored skills and craft references. The old upstream
+creative/workflow skills and guidance adapters have been removed. Retained
+technical references are adapted for GG's pinned launcher and local-only safety
+boundaries; do not restore entire upstream skill folders when updating the
+runtime.
 
 | Component | Source | Pinned at | License |
 |---|---|---|---|
@@ -14,17 +14,11 @@ upstream skill folders when updating the runtime.
 | Style-library pieces marked MIT (`library/pieces/<id>/`) | Magic UI, https://github.com/magicuidesign/magicui | converted 2026-09-28; upstream file URL in each `meta.json` | MIT (`LICENSE` beside each piece) |
 | Fonts (`fonts/<family>/`) | Google Fonts / https://github.com/google/fonts | fetched 2026-09-28 by `scripts/fetch-motion-fonts.mjs` | SIL OFL 1.1 (`OFL.txt` beside each family) |
 
-## Recipe and evidence boundaries
+## Content boundaries
 
-The Mixkit 617 recipe records the user's supplied project provenance and limits
-in its own skill/manifest. Extraction or purchase is not a redistribution license;
-its source/derivative-data rights require review before a public release. No AEP,
-source preview video or source font binary is bundled with that recipe.
-
-Private extraction tools, source projects, working exports and authoring-method
-documents are Git-ignored and excluded from release packaging. They are not
-runtime dependencies or additional callable skills. The normal video agent uses
-installed recipes; it does not run a parser or install authoring dependencies.
+Motion ships no templates derived from third-party After Effects or other
+motion projects. The earlier Mixkit, Mobile Notification and Kinetic Text
+reconstructions were removed on 2026-09-29 and are not part of any release.
 
 Existing `references/index.json`, signal sources and compact temporal JPEGs are
 GG studies, not private user videos or a universal style. They remain optional
@@ -34,14 +28,15 @@ licenses remain with their sources.
 
 The Motion-only preference reader and review tool do not load Coder instructions.
 Review remains bounded and tied to current source/render evidence. It checks the
-selected recipe and approved inputs, not a competing art direction, and does not
+video's plan and approved inputs, not a competing art direction, and does not
 claim full playback or aesthetic certification from model image critique.
 
 ## Fonts
 
-15 families, listed in `fonts/fonts.json`. Latin-subset variable woff2 as served
-by Google Fonts, except Mona Sans and Hubot Sans: they carry OFL Reserved Font
-Names and ship as complete upstream fonts, recompressed to woff2. `fonts.mjs add`
+19 families, listed in `fonts/fonts.json`. Latin-subset variable woff2 as served
+by Google Fonts, except Mona Sans, Hubot Sans, Short Stack and Finger Paint: they
+carry OFL Reserved Font Names and ship as complete upstream fonts, recompressed
+to woff2. Unbounded, Sora, Short Stack and Finger Paint were added 2026-09-29. `fonts.mjs add`
 copies each family's `OFL.txt` into the video project with its font files.
 
 ## Shared audio retained from brag

package/assets/motion/bin/flash-check.mjs

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+// Photosensitivity screen on decoded pixels against the WCAG 2.3.1 general and red flash
+// thresholds. As in EA's open-source IRIS tool, an area's mean change only counts on frames
+// where at least a quarter of the area changes, so moving content mostly cancels out rather
+// than reading as flashing. IRIS applies this to the whole screen; here it applies to every
+// WCAG 10° field (a third of the frame each way), so a flash filling part of the frame is
+// caught too. A transition is a move of 0.1 relative luminance (or 20 red units) away from the
+// last peak or valley, as WCAG defines it; more than six in any second fails. Renders above
+// 60 fps are sampled at 60. A screen, not a certification.
+import { spawn } from "node:child_process";
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { once } from "node:events";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { ffmpegBinary } from "./media-binaries.mjs";
+
+/** Cells per side of the analysis grid; every aspect ratio maps onto it. */
+export const GRID = 48;
+/** Frames per analysed second; slower renders are repeated, so one second is always 60 frames. */
+export const ANALYSIS_FPS = 60;
+/** WCAG approximates the 10° field as 341×256 px of a 1024×768 screen: a third each way. */
+const FIELD = GRID / 3;
+const FIELD_CELLS = FIELD * FIELD;
+/** A field's change counts once a quarter of it changes. */
+const AREA = 0.25 * FIELD_CELLS;
+const WINDOWS_PER_SIDE = GRID - FIELD + 1;
+const WINDOWS = WINDOWS_PER_SIDE * WINDOWS_PER_SIDE;
+/** More than three flashes (six opposing transitions) within any one second fails. */
+const MAX_TRANSITIONS = 6;
+/** Transitions per field within the trailing second never exceed one per analysed frame. */
+const RING = 64;
+const CELLS = GRID * GRID;
+const FRAME_BYTES = CELLS * 3;
+const CHANNELS = {
+  // Relative luminance 0–1: a 0.1 swing, unless even the darker state is 0.8 or brighter.
+  // A cell has changed once it moves by more than encoding noise (about 1/255 linear).
+  general: { threshold: 0.1, darkLimit: 0.8, noise: 0.004 },
+  // WCAG's red measure: (R − G − B) × 320 where R / (R + G + B) ≥ 0.8, else 0.
+  red: { threshold: 20, darkLimit: Infinity, noise: 1 },
+};
+/** sRGB to linear light, applied before averaging so mixed cells keep their real brightness. */
+const LINEAR = "if(lte(val,10.31475),val/12.92,255*pow((val/255+0.055)/1.055,2.4))";
+
+function createChannel({ threshold, darkLimit, noise }) {
+  const side = GRID + 1;
+  const changed = new Float64Array(side * side);
+  const change = new Float64Array(side * side);
+  const level = new Float64Array(side * side);
+  // Per field: the accumulated counted change, its last peak and valley, and the field's
+  // mean at each, for WCAG's "darker image" rule.
+  const signal = new Float64Array(WINDOWS);
+  const peakValue = new Float64Array(WINDOWS);
+  const peakLevel = new Float64Array(WINDOWS);
+  const valleyValue = new Float64Array(WINDOWS);
+  const valleyLevel = new Float64Array(WINDOWS);
+  /** 1 after a rise, -1 after a fall, 0 before the first transition. */
+  const direction = new Int8Array(WINDOWS);
+  const ring = new Int32Array(WINDOWS * RING);
+  const head = new Int32Array(WINDOWS);
+  const tail = new Int32Array(WINDOWS);
+  const failures = [];
+  let peak = 0;
+
+  return {
+    update(frame, previous, current) {
+      // Summed-area tables, so each field's totals cost four lookups.
+      for (let y = 0; y < GRID; y++) {
+        let rowChanged = 0;
+        let rowChange = 0;
+        let rowLevel = 0;
+        for (let x = 0; x < GRID; x++) {
+          const cell = y * GRID + x;
+          const delta = current[cell] - previous[cell];
+          if (Math.abs(delta) > noise) rowChanged++;
+          rowChange += delta;
+          rowLevel += current[cell];
+          const at = (y + 1) * side + x + 1;
+          changed[at] = changed[at - side] + rowChanged;
+          change[at] = change[at - side] + rowChange;
+          level[at] = level[at - side] + rowLevel;
+        }
+      }
+      let most = 0;
+      for (let wy = 0; wy < WINDOWS_PER_SIDE; wy++) {
+        for (let wx = 0; wx < WINDOWS_PER_SIDE; wx++) {
+          const window = wy * WINDOWS_PER_SIDE + wx;
+          const a = wy * side + wx;
+          const b = a + FIELD;
+          const c = a + FIELD * side;
+          const d = c + FIELD;
+          const area = changed[d] - changed[b] - changed[c] + changed[a];
+          const step = (change[d] - change[b] - change[c] + change[a]) / FIELD_CELLS;
+          const mean = (level[d] - level[b] - level[c] + level[a]) / FIELD_CELLS;
+          if (frame === 1) {
+            peakLevel[window] = mean - step;
+            valleyLevel[window] = mean - step;
+          }
+          const value = signal[window] + (area >= AREA ? step : 0);
+          signal[window] = value;
+          let transition = false;
+          if (direction[window] >= 0) {
+            if (value > peakValue[window]) {
+              peakValue[window] = value;
+              peakLevel[window] = mean;
+            } else if (peakValue[window] - value >= threshold) {
+              transition = Math.min(mean, peakLevel[window]) < darkLimit;
+              direction[window] = -1;
+              valleyValue[window] = value;
+              valleyLevel[window] = mean;
+            }
+          }
+          if (direction[window] <= 0) {
+            if (value < valleyValue[window]) {
+              valleyValue[window] = value;
+              valleyLevel[window] = mean;
+            } else if (value - valleyValue[window] >= threshold) {
+              transition = Math.min(mean, valleyLevel[window]) < darkLimit;
+              direction[window] = 1;
+              peakValue[window] = value;
+              peakLevel[window] = mean;
+            }
+          }
+          const base = window * RING;
+          while (
+            tail[window] < head[window] &&
+            frame - ring[base + (tail[window] % RING)] >= ANALYSIS_FPS
+          )
+            tail[window]++;
+          if (transition) {
+            ring[base + (head[window] % RING)] = frame;
+            head[window]++;
+          }
+          const count = head[window] - tail[window];
+          if (count > most) most = count;
+        }
+      }
+      peak = Math.max(peak, most);
+      if (most > MAX_TRANSITIONS) {
+        const start = Math.max(0, frame + 1 - ANALYSIS_FPS) / ANALYSIS_FPS;
+        const end = (frame + 1) / ANALYSIS_FPS;
+        const last = failures.at(-1);
+        if (last && start <= last.end) last.end = end;
+        else failures.push({ start, end });
+      }
+    },
+    summary() {
+      return {
+        maxFlashesPerSecond: peak / 2,
+        failures: failures.slice(0, 20).map(({ start, end }) => ({
+          start: Math.round(start * 100) / 100,
+          end: Math.round(end * 100) / 100,
+        })),
+      };
+    },
+  };
+}
+
+/** Pure analysis over linear-light RGB frames of GRID × GRID cells (3 bytes per cell). */
+export function createFlashAnalyzer() {
+  const general = createChannel(CHANNELS.general);
+  const red = createChannel(CHANNELS.red);
+  let luminance = new Float64Array(CELLS);
+  let redness = new Float64Array(CELLS);
+  let previousLuminance = new Float64Array(CELLS);
+  let previousRedness = new Float64Array(CELLS);
+  let frames = 0;
+  return {
+    push(frame) {
+      if (!(frame instanceof Uint8Array) || frame.length !== FRAME_BYTES)
+        throw new Error(`Expected ${FRAME_BYTES}-byte analysis frames`);
+      for (let cell = 0; cell < CELLS; cell++) {
+        const r = frame[cell * 3] / 255;
+        const g = frame[cell * 3 + 1] / 255;
+        const b = frame[cell * 3 + 2] / 255;
+        luminance[cell] = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+        const total = r + g + b;
+        redness[cell] = total > 0 && r / total >= 0.8 ? Math.max(0, (r - g - b) * 320) : 0;
+      }
+      if (frames > 0) {
+        general.update(frames, previousLuminance, luminance);
+        red.update(frames, previousRedness, redness);
+      }
+      [previousLuminance, luminance] = [luminance, previousLuminance];
+      [previousRedness, redness] = [redness, previousRedness];
+      frames++;
+    },
+    result() {
+      const generalSummary = general.summary();
+      const redSummary = red.summary();
+      return {
+        ok: frames >= 2 && !generalSummary.failures.length && !redSummary.failures.length,
+        method: "rendered-pixels",
+        standard: "WCAG 2.3.1 general and red flash thresholds",
+        analysisFps: ANALYSIS_FPS,
+        frames,
+        duration: frames / ANALYSIS_FPS,
+        general: generalSummary,
+        red: redSummary,
+      };
+    },
+  };
+}
+
+/** Decode a video into linear-light analysis frames and return the flash report. */
+export async function analyzeFlashes(file, signal) {
+  const binary = await ffmpegBinary();
+  const child = spawn(
+    binary,
+    [
+      "-hide_banner",
+      "-nostdin",
+      "-loglevel",
+      "error",
+      "-xerror",
+      "-protocol_whitelist",
+      "file,pipe",
+      "-i",
+      file,
+      "-map",
+      "0:v:0",
+      "-an",
+      "-vf",
+      [
+        // Linearise before any averaging: shrinking sRGB values first darkens fine detail
+        // by up to half the flash threshold.
+        "format=gbrp",
+        `lutrgb=r='${LINEAR}':g='${LINEAR}':b='${LINEAR}'`,
+        `scale=${GRID}:${GRID}:flags=area`,
+        `fps=${ANALYSIS_FPS}`,
+        "format=rgb24",
+      ].join(","),
+      "-f",
+      "rawvideo",
+      "-pix_fmt",
+      "rgb24",
+      "pipe:1",
+    ],
+    { stdio: ["ignore", "pipe", "pipe"], windowsHide: true, signal },
+  );
+  let stderr = "";
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (text) => {
+    if (stderr.length < 16_000) stderr += text;
+  });
+  const closed = once(child, "close");
+  closed.catch(() => {});
+  const analyzer = createFlashAnalyzer();
+  const frame = new Uint8Array(FRAME_BYTES);
+  let filled = 0;
+  for await (const chunk of child.stdout) {
+    let offset = 0;
+    while (offset < chunk.length) {
+      const take = Math.min(FRAME_BYTES - filled, chunk.length - offset);
+      frame.set(chunk.subarray(offset, offset + take), filled);
+      filled += take;
+      offset += take;
+      if (filled === FRAME_BYTES) {
+        analyzer.push(frame);
+        filled = 0;
+      }
+    }
+  }
+  const [code] = await closed;
+  if (code !== 0)
+    throw new Error(`FFmpeg could not decode the video: ${stderr.trim().slice(-2000)}`);
+  if (filled !== 0) throw new Error("Decoded video ended mid-frame; flashing is unverified");
+  const result = analyzer.result();
+  if (result.frames < 2) throw new Error("Too few decoded frames; flashing is unverified");
+  return result;
+}
+
+async function videoHash(file, signal) {
+  const hash = createHash("sha256");
+  for await (const chunk of createReadStream(file, { signal })) hash.update(chunk);
+  return hash.digest("hex");
+}
+
+async function main() {
+  const [video, ...extra] = process.argv.slice(2);
+  if (!video || extra.length) throw new Error("usage: flash-check.mjs <rendered-video>");
+  const file = resolve(video);
+  if (!(await stat(file)).isFile()) throw new Error("Expected a local rendered video file");
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  process.once("SIGTERM", abort);
+  process.once("SIGINT", abort);
+  const started = performance.now();
+  try {
+    const videoSha256 = await videoHash(file, controller.signal);
+    const result = await analyzeFlashes(file, controller.signal);
+    if ((await videoHash(file, controller.signal)) !== videoSha256)
+      throw new Error("Video changed during analysis; flashing is unverified");
+    process.stdout.write(
+      `${JSON.stringify({ ...result, file, videoSha256, elapsedMs: Math.round(performance.now() - started) })}\n`,
+    );
+    if (!result.ok) process.exitCode = 1;
+  } finally {
+    process.removeListener("SIGTERM", abort);
+    process.removeListener("SIGINT", abort);
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  try {
+    await main();
+  } catch (error) {
+    process.stderr.write(
+      `Flash verification failed: ${error instanceof Error ? error.message : "invalid input"}\n`,
+    );
+    process.exitCode = 1;
+  }
+}

package/assets/motion/bin/fonts.mjs

@@ -7,9 +7,11 @@
 //   node fonts.mjs add <project-dir> <Family> [<Family> ...]
 //
 // `add` copies each family's woff2 files and OFL.txt into
-// <project>/assets/fonts/<family>/ and rewrites <project>/assets/fonts/fonts.css
-// with an @font-face for every bundled family installed there. Link it from
-// the composition <head>: <link rel="stylesheet" href="assets/fonts/fonts.css">.
+// <project>/assets/fonts/<family>/, rewrites <project>/assets/fonts/fonts.css,
+// and returns `head`: a <style> block with an @font-face for every bundled
+// family installed there, using project-relative paths. Paste `head` into the
+// composition <head>. `hf check` only sees @font-face written in the page, so a
+// linked fonts.css renders but is reported as missing fonts.
 // Prints one JSON line: {"ok":true,...} or {"ok":false,"error":...}.
 import { copyFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
@@ -23,15 +25,16 @@ function done(result, code = 0) {
 }
 const fail = (error) => done({ ok: false, error }, 1);
 
-/** @returns {Promise<Array<{family:string,dir:string,license:string,files:Array<{file:string,style:string,weight:string,stretch:string|null}>}>>} */
+/** @returns {Promise<Array<{family:string,dir:string,license:string,use?:string,files:Array<{file:string,style:string,weight:string,stretch:string|null}>}>>} */
 async function manifest() {
   return JSON.parse(await readFile(join(LIBRARY, "fonts.json"), "utf8"));
 }
 
-function fontFace(entry, file) {
+/** `base` is the font folder as seen from the file that holds the rule. */
+function fontFace(entry, file, base = "") {
   const lines = [
     `  font-family: "${entry.family}";`,
-    `  src: url("${entry.dir}/${file.file}") format("woff2");`,
+    `  src: url("${base}${entry.dir}/${file.file}") format("woff2");`,
     `  font-style: ${file.style};`,
     `  font-weight: ${file.weight};`,
   ];
@@ -52,6 +55,7 @@ if (command === "list") {
       styles: f.files.map((file) => file.style),
       weight: f.files[0]?.weight,
       width: f.files[0]?.stretch ?? null,
+      ...(f.use ? { use: f.use } : {}),
     })),
   });
 }
@@ -93,15 +97,15 @@ for (const entry of fonts) {
   );
   if (present) installed.push(entry);
 }
-const css = [
-  "/* Generated by EZ Motion fonts.mjs. SIL OFL 1.1: licenses sit beside each family. */",
-  ...installed.flatMap((entry) => entry.files.map((file) => fontFace(entry, file))),
-].join("\n\n");
-await writeFile(join(target, "fonts.css"), `${css}\n`);
+const rules = (base) =>
+  installed.flatMap((entry) => entry.files.map((file) => fontFace(entry, file, base)));
+const header =
+  "/* Generated by EZ Motion fonts.mjs. SIL OFL 1.1: licenses sit beside each family. */";
+await writeFile(join(target, "fonts.css"), `${[header, ...rules("")].join("\n\n")}\n`);
 
 done({
   ok: true,
   installed: installed.map((f) => f.family),
-  stylesheet: join(target, "fonts.css"),
-  link: '<link rel="stylesheet" href="assets/fonts/fonts.css" />',
+  head: `<style>\n${[header, ...rules("assets/fonts/")].join("\n")}\n</style>`,
+  use: "Paste head into the composition <head>, replacing any earlier fonts block.",
 });

package/assets/motion/bin/library.mjs

@@ -46,14 +46,16 @@ async function projectDir(arg) {
   return dir;
 }
 
+/** Returns the installed families and fonts.mjs's page-ready <style> block. */
 function installFonts(project, families) {
-  if (families.length === 0) return [];
+  if (families.length === 0) return { installed: [], head: [] };
   const out = execFileSync(process.execPath, [join(BIN, "fonts.mjs"), "add", project, ...families], {
     encoding: "utf8",
   });
   const result = JSON.parse(out);
   if (!result.ok) fail(`Font install failed: ${result.error}`);
-  return result.installed;
+  // Inline, not a linked fonts.css: `hf check` only sees @font-face written in the page.
+  return { installed: result.installed, head: [result.head] };
 }
 
 const summary = (entry, type) => ({
@@ -135,11 +137,9 @@ if (command === "look") {
     ok: true,
     look: look.id,
     tokens: css,
-    fonts,
-    head: [
-      '<link rel="stylesheet" href="assets/fonts/fonts.css" />',
-      `<link rel="stylesheet" href="assets/looks/${look.id}.css" />`,
-    ],
+    fonts: fonts.installed,
+    head: [...fonts.head, `<link rel="stylesheet" href="assets/looks/${look.id}.css" />`],
+    use: "Paste head into the composition <head>, replacing any earlier fonts block.",
     root: `add class="look-${look.id}" to the root composition element`,
     spec: join(LIBRARY, "looks", look.id, "look.md"),
   });
@@ -196,7 +196,7 @@ if (command === "add") {
     ok: true,
     added,
     kept,
-    fonts,
+    fonts: fonts.installed,
     ...(importmap ? { importmap, note: "put importmap in index.html <head> before any module script" } : {}),
     mount: pieces.map(
       (p) =>

package/assets/motion/bin/motion-check.mjs

@@ -102,12 +102,18 @@ export function parseMotionOutput(text, slideshowRequested = false, holds = [])
       error:
         "Holds cannot exempt the entire video; explicitly requested slideshows use their own mode",
     };
-  if (
-    holds.some(
-      (hold) => !freezes.some((freeze) => freeze.end > hold.start && freeze.start < hold.end),
-    )
-  )
-    return { ok: false, error: "Stale hold declaration: no detected freeze overlaps its window" };
+  const staleHolds = holds.filter(
+    (hold) => !freezes.some((freeze) => freeze.end > hold.start && freeze.start < hold.end),
+  );
+  // Name the stale holds and where pixels actually freeze, so the plan is fixed in one
+  // step instead of guessed again against another full check.
+  if (staleHolds.length)
+    return {
+      ok: false,
+      error: "Stale hold declaration: no detected freeze overlaps its window",
+      staleHolds,
+      freezes,
+    };
   const unexpectedFreezes = freezes.filter(
     (freeze) =>
       !holds.some(

package/assets/motion/fonts/finger-paint/OFL.txt

@@ -0,0 +1,93 @@
+Copyright (c) 2011 by Ralph du Carrois, with Reserved Font Name 'Finger Paint'
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.