@docyrus/animaguru 0.6.0

package/templates/video/src/studies/timing.ts

@@ -0,0 +1,53 @@
+/** Absolute-time helpers: no frame history, uncontrolled timers or random sampling. */
+export const clamp = (v: number, min = 0, max = 1) => Math.max(min, Math.min(max, v));
+export const lerp = (a: number, b: number, t: number) => a + (b - a) * t;
+export const ease = (t: number) => 1 - (1 - clamp(t)) ** 3;
+export const progress = (t: number, at: number, duration = 1) => ease((t - at) / duration);
+export const hash = (n: number) => { const x = Math.sin(n * 127.1 + 311.7) * 43758.5453; return x - Math.floor(x); };
+export const sampled = (t: number, cadence: number) => Math.floor(t * cadence) / cadence;
+/** Critically damped response with an explicit initial velocity. */
+export function spring(t: number, from: number, to: number, speed = 12, velocity = 0) {
+  if (t <= 0)
+    return from;
+  const displacement = from - to;
+  return to + (displacement + (velocity + speed * displacement) * t) * Math.exp(-speed * t);
+}
+export type Point = readonly [
+  number,
+  number
+];
+/** Truncate a polyline by measured arc length, preserving completed segments. */
+export function strokePoints(points: readonly Point[], amount: number): Point[] {
+  if (!points.length)
+    return [];
+  let total = 0;
+  for (let i = 1; i < points.length; i++)
+    total += Math.hypot(points[i][0] - points[i - 1][0], points[i][1] - points[i - 1][1]);
+  let remaining = total * clamp(amount);
+  const result: Point[] = [points[0]];
+  for (let i = 1; i < points.length; i++) {
+    const a = points[i - 1], b = points[i];
+    const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    if (remaining >= length) {
+      result.push(b);
+      remaining -= length;
+    }
+    else {
+      if (length > 0)
+        result.push([lerp(a[0], b[0], remaining / length), lerp(a[1], b[1], remaining / length)]);
+      break;
+    }
+  }
+  return result;
+}
+export type Cue = {
+  id: string;
+  time: number;
+  audioTime?: number;
+  label: string;
+};
+export function cueDifferences(cues: readonly Cue[], fps: number) {
+  return cues.filter((cue) => cue.audioTime !== undefined).map((cue) => ({
+    ...cue, delta: Math.abs(cue.time - cue.audioTime!), pass: Math.abs(cue.time - cue.audioTime!) <= 1 / fps,
+  }));
+}

package/templates/video/src/studies/variants.ts

@@ -0,0 +1,39 @@
+import { clamp, spring, type Point } from "./timing";
+type TargetChange = {
+  time: number;
+  value: number;
+};
+/** Sum target changes so interrupted UI springs remain cold-seekable and continuous. */
+export function springTrack(initial: number, changes: readonly TargetChange[], seconds: number, speed = 12) {
+  let value = initial, previous = initial;
+  for (const change of changes) {
+    if (seconds < change.time)
+      break;
+    value += spring(seconds - change.time, 0, change.value - previous, speed);
+    previous = change.value;
+  }
+  return value;
+}
+/** Palette changes preserve explicitly protected semantic indices. */
+export function remapPalette(indices: Uint8Array, lookup: readonly number[], protectedIndices: ReadonlySet<number> = new Set()) {
+  return Uint8Array.from(indices, (index) => protectedIndices.has(index) ? index : lookup[index] ?? index);
+}
+/** A data-space annotation and its plot marks must share this projection. */
+export function plotPoint(value: Point, xDomain: Point, yDomain: Point, box: {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}): Point {
+  if (xDomain[0] === xDomain[1] || yDomain[0] === yDomain[1])
+    throw new Error("Plot domain has no range.");
+  return [box.x + (value[0] - xDomain[0]) / (xDomain[1] - xDomain[0]) * box.width, box.y + box.height - (value[1] - yDomain[0]) / (yDomain[1] - yDomain[0]) * box.height];
+}
+/** A known stroke length and deadline determine reveal, rather than accumulated pen speed. */
+export function strokeSchedule(lengths: readonly number[], start: number, end: number, seconds: number) {
+  if (end <= start || lengths.some((length) => length < 0 || !Number.isFinite(length)))
+    throw new Error("Invalid stroke schedule.");
+  const total = lengths.reduce((sum, length) => sum + length, 0);
+  let cursor = 0;
+  return lengths.map((length) => { const from = cursor; cursor += length; return length ? clamp((total * clamp((seconds - start) / (end - start)) - from) / length) : 0; });
+}

package/templates/video/src/style.css

@@ -0,0 +1,111 @@
+* { box-sizing: border-box; }
+:root { font-family: Arial, Helvetica, sans-serif; color: #172624; background: #f5f3ed; font-synthesis: none; }
+body { margin: 0; }
+button, input { font: inherit; }
+button, a, summary { -webkit-tap-highlight-color: transparent; }
+button { cursor: pointer; }
+button:disabled { cursor: default; opacity: .48; }
+button:focus-visible, a:focus-visible, input:focus-visible, summary:focus-visible { outline: 3px solid #2c6bd0; outline-offset: 5px; }
+.masthead { max-width: 1536px; margin: auto; padding: 27px 48px; display: flex; align-items: center; justify-content: space-between; border-bottom: 1px solid #dcded4; gap: 20px; }
+.brand { display: flex; align-items: center; gap: 10px; text-decoration: none; color: inherit; }
+.brand img { width: 35px; height: 35px; }
+.brand strong { font-size: 23px; letter-spacing: -.9px; }
+.brand span { margin-left: 18px; padding-left: 24px; border-left: 1px solid #c9d0c6; font-size: 12px; color: #6b786e; }
+.template { padding: 9px 14px; border: 1px solid #cad0c2; border-radius: 50px; font-size: 11px; }
+main { max-width: 1380px; margin: auto; padding: 45px 48px 15px; }
+.eyebrow { font-size: 10px; font-weight: 700; letter-spacing: 1.9px; margin: 0 0 12px; color: #667660; }
+.specs { font: 10px monospace; color: #6a7668; white-space: nowrap; }
+#theater { border-radius: 17px; overflow: hidden; border: 1px solid #d9ddcf; background: #f4f1e9; box-shadow: 0 16px 60px #1726240d; }
+#canvas-host { width: 100%; position: relative; aspect-ratio: 16 / 9; }
+#canvas-host canvas { display: block; width: 100%; height: 100%; object-fit: contain; }
+#loading { position: absolute; inset: 45% 0 auto; text-align: center; color: #788073; }
+.transport { display: flex; align-items: center; gap: 16px; padding: 15px 20px; background: #fffcf5; border-top: 1px solid #e7e6dc; }
+.transport button { border: 0; background: transparent; font-size: 11px; color: #374b40; padding: 9px 6px; white-space: nowrap; border-radius: 7px; }
+.transport .primary { min-width: 68px; background: #263f32; color: #fff; padding: 10px 16px; }
+.transport button:hover { background: #e6ebdd; color: #172624; }
+#time { font: 11px monospace; white-space: nowrap; color: #657460; }
+#timeline { min-width: 50px; flex: 1; accent-color: #356748; height: 4px; }
+.tools { display: flex; align-items: center; gap: 8px; }
+.transport .icon-button { display: grid; place-items: center; width: 36px; height: 36px; padding: 8px; }
+.icon-button svg { width: 19px; height: 19px; pointer-events: none; }
+.download-control { position: relative; }
+#download-menu { position: absolute; right: 0; bottom: calc(100% + 9px); z-index: 5; width: 200px; padding: 6px; background: #fffcf5; border: 1px solid #daddcf; border-radius: 12px; box-shadow: 0 8px 32px #17262426; }
+#download-menu button { display: flex; align-items: center; justify-content: space-between; gap: 14px; width: 100%; padding: 12px 10px; text-align: left; font-size: 12px; }
+#download-menu small { color: #77836f; font-size: 10px; }
+#captions[aria-pressed="true"] { background: #e7ecdc; font-weight: 700; }
+.player-note { display: flex; justify-content: space-between; gap: 15px; color: #7b8174; font-size: 10px; margin: 14px 2px 0; }
+.preview-meta { display: flex; flex-wrap: wrap; align-items: center; gap: 9px; }
+#status { color: #9a391c; font-size: 13px; margin: 10px 0; }
+.resource-timeline { min-width: 0; margin: 32px 0; border: 1px solid #daddcf; border-radius: 12px; overflow: hidden; background: #fbf9f3; }
+.timeline-toolbar { display: flex; align-items: center; justify-content: space-between; gap: 12px; padding: 15px 16px; border-bottom: 1px solid #daddcf; }
+.timeline-toolbar .eyebrow { font-size: 9px; margin: 0 0 5px; }
+.timeline-count { font-size: 10px; color: #809078; }
+.timeline-zoom { display: flex; align-items: center; gap: 5px; }
+.timeline-zoom button { display: grid; place-items: center; border: 1px solid #d9dfd0; background: #f6f7ee; color: #3c5343; border-radius: 5px; min-width: 27px; height: 28px; padding: 4px 7px; font-size: 10px; }
+.timeline-zoom button:hover:enabled { background: #e3ead8; }
+.timeline-zoom svg { width: 13px; height: 13px; }
+.zoom-level { font: 9px monospace; min-width: 36px; text-align: center; color: #667a61; }
+.timeline-clock { margin-right: 10px; font: 11px monospace; color: #2c6bd0; font-variant-numeric: tabular-nums; }
+.timeline-viewport { height: auto; max-height: none; overflow-x: auto; overflow-y: hidden; overscroll-behavior-x: contain; scrollbar-width: thin; scrollbar-color: #c6cebd #f4f4eb; }
+.timeline-content { position: relative; }
+.timeline-ruler-row, .resource-row { display: grid; grid-template-columns: var(--resource-label-width, 160px) minmax(0, 1fr); }
+.timeline-ruler-row { position: sticky; top: 0; z-index: 6; height: 34px; background: #f2f3e9; border-bottom: 1px solid #d9dfcf; }
+.timeline-corner { position: sticky; left: 0; z-index: 7; padding: 11px 12px; background: #f2f3e9; border-right: 1px solid #d9dfcf; color: #7a8a72; font-size: 9px; }
+.timeline-ruler { position: relative; touch-action: none; cursor: col-resize; outline-offset: -3px; overflow: hidden; }
+.timeline-ruler:focus-visible { outline: 2px solid #2c6bd0; }
+.timeline-ticks { position: absolute; inset: 0; }
+.timeline-tick { position: absolute; top: 10px; bottom: 0; font: 9px monospace; color: #85937a; transform: translateX(-50%); pointer-events: none; }
+.timeline-tick::after { content: ""; position: absolute; bottom: 0; left: 50%; height: 5px; width: 1px; background: #abb69e; }
+.timeline-tick.first { transform: none; padding-left: 5px; }.timeline-tick.first::after { left: 0; }
+.timeline-tick.last { transform: translateX(-100%); padding-right: 5px; }.timeline-tick.last::after { left: auto; right: 0; }
+.timeline-handle { position: absolute; top: 0; bottom: 0; width: 2px; background: #2c6bd0; pointer-events: none; }
+.timeline-handle::before { content: ""; position: absolute; top: 0; left: -4px; width: 10px; height: 8px; background: #2c6bd0; clip-path: polygon(0 0,100% 0,100% 60%,50% 100%,0 60%); }
+.resource-row { height: 39px; border-bottom: 1px solid #e6e8dc; }
+.resource-label { position: sticky; left: 0; z-index: 4; display: flex; align-items: center; gap: 8px; min-width: 0; padding: 0 11px; background: #fbf9f3; border-right: 1px solid #d9dfcf; }
+.resource-icon { color: #819372; display: flex; flex: none; }.resource-icon svg { width: 14px; height: 14px; }
+.kind-text .resource-icon { color: #9a83b7; }.kind-captions .resource-icon { color: #ab914b; }.kind-audio .resource-icon { color: #438d7a; }.kind-video .resource-icon, .kind-image .resource-icon { color: #6388bd; }
+.resource-name { font-size: 10px; color: #596d52; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.resource-state { margin-left: auto; font-size: 8px; color: #8b927e; }
+.resource-lane { position: relative; background-image: linear-gradient(to right, #dfe4d480 1px, transparent 1px); background-size: var(--resource-grid-step, 100px) 100%; }
+.resource-clip { position: absolute; top: 5px; bottom: 5px; display: flex; align-items: center; min-width: 1px; max-width: 100%; border: 1px solid #c9d5ae; border-radius: 4px; background: #e3ebd1; color: #5b734a; padding: 0 7px; opacity: .72; text-align: left; overflow: hidden; }
+.resource-clip span { font-size: 9px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; pointer-events: none; }
+.kind-text .resource-clip { background: #ece4f3; border-color: #d9cce4; color: #836b98; }
+.kind-captions .resource-clip { background: #f4edcd; border-color: #e5d99f; color: #91792f; }
+.kind-audio .resource-clip { background: #d5e9df; border-color: #aed2c0; color: #3d7b62; }
+.kind-video .resource-clip, .kind-image .resource-clip { background: #dee8f4; border-color: #becfe8; color: #5b7fae; }
+.resource-clip.active, .resource-clip:hover { opacity: 1; filter: saturate(1.12); }
+.resource-clip.selected { border-color: #2c6bd0; box-shadow: inset 0 0 0 1px #2c6bd0; opacity: 1; }
+.resource-clip:focus-visible { outline-offset: -2px; }
+.resource-off .resource-clip { opacity: .32; }
+.resource-playhead { position: absolute; top: 34px; bottom: 0; z-index: 3; width: 1px; background: #2c6bd0; pointer-events: none; }
+.timeline-inspector { display: flex; flex-direction: column; justify-content: center; gap: 4px; min-height: 54px; padding: 11px 15px; border-top: 1px solid #daddcf; color: #859379; font-size: 10px; line-height: 1.5; overflow-wrap: anywhere; }
+.timeline-inspector strong { color: #4b644a; font-weight: 500; }
+details { font-size: 12px; color: #6e7b6a; margin: 25px 0 5px; }
+summary { cursor: pointer; width: fit-content; }
+#transcript { line-height: 1.8; }
+footer { max-width: 1380px; margin: auto; padding: 25px 48px; display: flex; justify-content: space-between; color: #85917e; font-size: 10px; }
+footer span:last-child { font-size: 8px; letter-spacing: 1.5px; }
+#theater:fullscreen { border: none; border-radius: 0; display: flex; flex-direction: column; justify-content: center; background: #15221c; }
+#theater:fullscreen #canvas-host { min-height: 0; flex: 1; aspect-ratio: auto; }
+.capture .masthead, .capture .transport, .capture .player-note, .capture #resource-timeline, .capture details, .capture footer { display: none; }
+.capture main { padding: 0; max-width: none; }
+.capture #theater { border: 0; border-radius: 0; box-shadow: none; }
+.capture #canvas-host { height: 100vh; aspect-ratio: auto; }
+.capture #status { display: none; }
+.embed { height: 100vh; overflow: hidden; }
+.embed #app, .embed main { height: 100%; }
+.embed main { padding: 0; max-width: none; }
+.embed .masthead, .embed .player-note, .embed #resource-timeline, .embed details, .embed footer, .embed .download-control, .embed #status { display: none; }
+.embed #theater { height: 100%; display: flex; flex-direction: column; border: 0; border-radius: 0; box-shadow: none; }
+.embed #canvas-host { flex: 1; min-height: 0; aspect-ratio: auto !important; }
+.embed .transport { flex: none; }
+.embed.no-controls .transport { display: none; }
+@media (max-width: 750px) {
+  .masthead { padding: 20px; }.brand span { display: none; }.brand strong { font-size: 20px; }.template { font-size: 9px; padding: 8px 10px; }
+  main { padding: 30px 20px 10px; }
+  .transport { flex-wrap: wrap; gap: 12px; padding: 12px; }.tools { justify-content: space-between; width: 100%; }.tools button { min-height: 36px; }
+  .player-note { flex-direction: column; gap: 6px; font-size: 9px; }
+  .timeline-toolbar { flex-wrap: wrap; padding: 13px; }.timeline-zoom { margin-left: auto; }.timeline-clock { margin-right: 4px; }
+  footer { padding: 25px 20px; }footer span:last-child { display: none; }
+}
+@media (prefers-reduced-motion: reduce) { * { scroll-behavior: auto; } }

package/templates/video/src/timeline-model.ts

@@ -0,0 +1,55 @@
+export type ResourceKind = "graphics" | "image" | "video" | "text" | "captions" | "audio";
+export type ResourceClip = { id: string; label: string; start: number; end: number; source?: string };
+export type ResourceTrack = { id: string; label: string; kind: ResourceKind; clips: ResourceClip[] };
+
+export function frameTime(seconds: number, duration: number, fps: number) {
+  return Math.max(0, Math.min(duration, Math.round((Number.isFinite(seconds) ? seconds : 0) * fps) / fps));
+}
+
+export function timecode(seconds: number, fps: number) {
+  const frames = Math.max(0, Math.round(seconds * fps));
+  const wholeSeconds = Math.floor(frames / fps);
+  return `${String(Math.floor(wholeSeconds / 60)).padStart(2, "0")}:${String(wholeSeconds % 60).padStart(2, "0")}:${String(frames % fps).padStart(2, "0")}`;
+}
+
+export function rulerTicks(duration: number, width: number, fps: number) {
+  const minimum = duration / Math.max(1, width / 76);
+  const steps = [1 / fps, 0.1, 0.2, 0.5, 1, 2, 5, 10, 15, 30, 60, 120, 300, 600];
+  const step = steps.find((value) => value >= minimum) ?? Math.ceil(minimum / 600) * 600;
+  const ticks = [0];
+  for (let value = step; value < duration; value += step) {
+    if (duration - value > step * 0.6) ticks.push(frameTime(value, duration, fps));
+  }
+  if (duration > 0) ticks.push(duration);
+  return [...new Set(ticks)];
+}
+
+export function clipRange(clip: ResourceClip, duration: number) {
+  const start = Math.max(0, clip.start);
+  const end = Math.min(duration, clip.end);
+  if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start || duration <= 0) return null;
+  return { start, end, left: start / duration * 100, width: (end - start) / duration * 100 };
+}
+
+/** Keep scrubbing responsive when decoding a video takes longer than pointer events. */
+export function createSeekQueue(seek: (seconds: number) => Promise<void>, onError: (error: unknown) => void) {
+  let pending: number | undefined;
+  let running = false;
+  let cancelled = false;
+  const drain = async () => {
+    if (running) return;
+    running = true;
+    try {
+      while (!cancelled && pending !== undefined) {
+        const time = pending;
+        pending = undefined;
+        await seek(time);
+      }
+    } catch (error) { pending = undefined; onError(error); }
+    finally { running = false; }
+  };
+  return {
+    request(seconds: number) { if (cancelled) return; pending = seconds; void drain(); },
+    cancel() { cancelled = true; pending = undefined; },
+  };
+}

package/templates/video/style-source-provenance.json

@@ -0,0 +1,11 @@
+{
+  "lemo-opuscar": {
+    "url": "https://github.com/lemomo-ai/lemo-opuscar",
+    "commit": "b65efe6ea393fdc71212898ea4c57c754cfefa46"
+  },
+  "awesome-opus5-5-videos": {
+    "url": "https://github.com/yihui-dev/awesome-opus5-5-videos",
+    "commit": "3d54892e2ae5b0e8d337171e6508bba4cec01ab8"
+  },
+  "scope": "Material and motion guidance; original scene study implementations. No source demo assets or creator footage bundled."
+}

package/templates/video/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "allowImportingTsExtensions": true,
+    "types": ["vite/client"]
+  },
+  "include": ["src"]
+}

package/templates/video/vite.config.mjs

@@ -0,0 +1,9 @@
+import { defineConfig } from "vite";
+import { fileURLToPath } from "node:url";
+import { htmlExportPlugin } from "./scripts/html-export-plugin.mjs";
+
+export default defineConfig({
+  base: "./",
+  server: { watch: { ignored: ["**/production/exports/**"] } },
+  plugins: [htmlExportPlugin(fileURLToPath(new URL("./", import.meta.url)))],
+});

package/vendor/pixijs-skills/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PixiJS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/pixijs-skills/provenance.json

@@ -0,0 +1,79 @@
+{
+  "source": "https://github.com/pixijs/pixijs-skills",
+  "license": "MIT",
+  "snapshotDate": "2026-10-06",
+  "origin": "Installed official skills snapshot; file hashes identify the bundled content.",
+  "files": {
+    "pixijs/SKILL.md": "2fdfe58823b46cad1d931747565016733e415ab07f2d3fb4dca58640b5ff82ce",
+    "pixijs/references/index.md": "d9cb110d63eedb6e79bfadbce86c56b2c253c55141eb89efeff787b2859c5ed9",
+    "pixijs-accessibility/SKILL.md": "4f97542f4209ae1031361bad982fd170e47490373cf3de68a6c018b9e58149bb",
+    "pixijs-application/SKILL.md": "99a4dc0e2625e3d95badf01b2a6715c1573f3ce5bfcd3298aaacf18533de12fb",
+    "pixijs-application/references/application-options.md": "071d9db92511f460f7f2d1d68186e1beb958764f5227060d295acf0cd21c352a",
+    "pixijs-assets/SKILL.md": "c34d4b5729ea9a8c7f085ab5150e294f670095580c718af985a3fcb3f8741ca9",
+    "pixijs-assets/references/background.md": "2fbd10a8297ab3c17217d89da721e4586806e27a986ce1fac8b44ae4bea2274c",
+    "pixijs-assets/references/bundles.md": "a624c5a8371e576d3078834c050711cb1ff44893ce72887eeddcc04bd0c9aef0",
+    "pixijs-assets/references/caching.md": "bfae76d4b28a312fe0a16dece584d6e3404d3af67579b7f6724b956dae0f3f49",
+    "pixijs-assets/references/compressed-textures.md": "8d155c18976921ed085fd0282e0001f409433dc6ca2933a71899648d5794db3e",
+    "pixijs-assets/references/fonts.md": "a8d205a18307c38bead2fb7833c230a1923126a9b6c75ea45b62a73814d7b017",
+    "pixijs-assets/references/gif.md": "b0c0ec364af806c0b199a9740e1a611f42b6f28c37c934c89832cd14f627aac7",
+    "pixijs-assets/references/manifests.md": "f8a082f85ebae434ad7f76990219f701e49661eddb72a5d92b9e1cdbb39624ac",
+    "pixijs-assets/references/progress.md": "e00dbb268ae044203bce83fd39ffaf0269eefa47fe3f3fba4b23a2a84a5dffad",
+    "pixijs-assets/references/resolution.md": "813e921bb8171a2f3d60d5fa95e549c4870b8850cdceef554b930bfb6d6bb53e",
+    "pixijs-assets/references/spritesheet.md": "61f8b710bbd8f619f63740a6691391963f7211afa3e40df2c94a09e348cfffe7",
+    "pixijs-assets/references/svg.md": "e12d2be0ad1fa1a9cd01c2662e35d1afe594071584473d0fed6ca670e9ea4171",
+    "pixijs-assets/references/video.md": "5f00ebd6d63028729c18dfe510608350a1380dd0140da21f2c1c1cd0a9770cc6",
+    "pixijs-blend-modes/SKILL.md": "a6caea6766b1dd31efa35171ec2a29ec5ea4e0728f14d6847570804f71feb1a5",
+    "pixijs-color/SKILL.md": "7635f6e165038a96602b161273f2549bc74ebe51e147eab4c7c1811cc988c3b9",
+    "pixijs-core-concepts/SKILL.md": "cf632dd602779c0f584fdbb6f5b0a022c68cfdb408882c243ba0cff43d2957d9",
+    "pixijs-core-concepts/references/render-loop.md": "5f70bb13b0315ceed2d828011eceacc56596ff98092569092fed4f8c40c5fad1",
+    "pixijs-core-concepts/references/renderers.md": "4863dfb738d4d31e1801b421844eae72c92d7c7b702779f79fc82484d2da3fc9",
+    "pixijs-create/SKILL.md": "a254ac504b83bf276f56f20ff89f5bbb5fbb3a8fdc7be67c957ecb834ae3ec71",
+    "pixijs-custom-rendering/SKILL.md": "0037d1fbdd82652c0fc32491f34d02287d84c2db49deb65ac024307b8d01021b",
+    "pixijs-custom-rendering/references/advanced-gpu.md": "ffbde5ee149d75f579ad9264d9ccfa11e4aa88a9633a75176e7fe72d50d4c8cd",
+    "pixijs-custom-rendering/references/uniform-types.md": "dee566401a5bc795bb9ef6bc1a0a58fd23ac7850dbe6af55d8952a8927e574d7",
+    "pixijs-environments/SKILL.md": "5cfab873cbf8c68ce3e010bc96262d88e4e924ae6fa8345c614ae8256f22360e",
+    "pixijs-events/SKILL.md": "a74a29339baa9bc80ceb1f4e837736edb2c5afb62ff34dab89d1ab0a0cc9e4b7",
+    "pixijs-filters/SKILL.md": "bdf834030fff36be20f0c566d970999ae2429994487a56054be8d2dc8d26a056",
+    "pixijs-html-source/SKILL.md": "8061235e80fad00c23ca274d67e0198246b49c6093511fa983ca347ba2ceb492",
+    "pixijs-math/SKILL.md": "62a2df69568937cb3353d67b9dc35b19db7cba477f179f34137d110b12989550",
+    "pixijs-migration-v8/SKILL.md": "e3c1c40b5c8385df6eb055067c9c23598d78d1b96cf519a97b2acb3f3b057cad",
+    "pixijs-performance/SKILL.md": "994bcad9687a5ad698b466436ad7d1120e47864bfadb86c9d17180fe90cf194b",
+    "pixijs-scene-container/SKILL.md": "8d4ba1f4a3a7703b86cfce896119556dd624636a40c2db0d70c9b29b2f62b246",
+    "pixijs-scene-core-concepts/SKILL.md": "ad9f459a74de66784d1ba7930fc080cfaf14b38a79f4e6a10185f23914998f40",
+    "pixijs-scene-core-concepts/references/constructor-options.md": "b49d74adeaed4820497b2aef62e934a18ea83e4fc03dd7feb67552a2e3fff3b7",
+    "pixijs-scene-core-concepts/references/container-hierarchy.md": "3affc169278cce85b89cd09c2851bfa251c1ca7addcfb92243d51b4e355fe10a",
+    "pixijs-scene-core-concepts/references/layers.md": "7725724b7cf7f0f6954a8efdbe1cb1ac7d5b3c2e1e44042ebe5eb5e6c07c507e",
+    "pixijs-scene-core-concepts/references/masking.md": "247543de62c58604c8b677cce54b85e271b75cda086c46da6cbad4e6537cba3b",
+    "pixijs-scene-core-concepts/references/render-groups.md": "7eaee69a0fcc41f1a946bf37a227d90e054e3914b6301ecf5468a882f7a0d92c",
+    "pixijs-scene-core-concepts/references/scene-management.md": "5433c35f8c57621b7b4d1e719a6d2ad433b9831b3ece2a5cb5417cdc3ed4ddb9",
+    "pixijs-scene-core-concepts/references/transforms.md": "6e8c76a297fb14b96f2a9b12e9c7b7c586a5509e680391e318b5dc90513c8ad6",
+    "pixijs-scene-dom-container/SKILL.md": "6c65323e40999ca97ad752758148193e55185706a44b8656e278a237d88c2a22",
+    "pixijs-scene-gif/SKILL.md": "9f8e2f9e2c70ba427695e67126948188e2868109e86449f31e06b822fe2ae078",
+    "pixijs-scene-graphics/SKILL.md": "7a1e683086170b086d4e79f5d80bd760b67ce63b90b30d17ef2079ae22c746a0",
+    "pixijs-scene-mesh/SKILL.md": "64b76b7d10b8cb3e38239bc9a54e314ef70812ce2828ff35b5bdec6800c53448",
+    "pixijs-scene-mesh/references/mesh-perspective.md": "65f267d9627c7f0521f9810acca266710a7c6522cc8348b44f432776f18bb7df",
+    "pixijs-scene-mesh/references/mesh-plane.md": "803f49721b848b3383f4d8c84c7a0c674f05cfc2495b01c7e7f90fe6b86cc490",
+    "pixijs-scene-mesh/references/mesh-rope.md": "2849b988460d8798936206a467f46b678d20b2fe1d07f1a44b745ec0e04731ca",
+    "pixijs-scene-mesh/references/mesh-simple.md": "2b5899de195268262555b576e981632554665b376197949a7b1330f7bab205c9",
+    "pixijs-scene-mesh/references/mesh.md": "e0aa3b7488eb14aecc183b88a5ac1c674aefbc48e9d5d87f99232727ca65f542",
+    "pixijs-scene-particle-container/SKILL.md": "b322029602cbb088bd298e5b914f8056e4539a50f1d6054e5d183c11b731bfdf",
+    "pixijs-scene-sprite/SKILL.md": "2ca79e5aaedea4898f7a972676fa93166a6c35ebe1ab63b8331e76899e081345",
+    "pixijs-scene-sprite/references/animated-sprite.md": "5fa8fe00d5714f7a6d5ceb0d88e99a03ad8b57fe147ed0c8e5608bfcb957657d",
+    "pixijs-scene-sprite/references/nineslice-sprite.md": "e82b46b27ca57da9900d4981fe3e2e7cc4ade00064232053b2e8bbf744da37f3",
+    "pixijs-scene-sprite/references/sprite.md": "1fefed94d0f5f8c6d8e78a860234076a8124ab14f8a618d3e8b61b51525da0af",
+    "pixijs-scene-sprite/references/tiling-sprite.md": "e2645352a1f432997f5fbcd94a3b523ac750f73b444ec1df44471de61ef479db",
+    "pixijs-scene-text/SKILL.md": "1ebbd6a643050af5bc42c6db445029149e6d17b7af132db4772792ee33106472",
+    "pixijs-scene-text/references/bitmap-text.md": "696f4227edef38c150a7bdb8caa1fa2ae8d23742d318af6391f57b1b325a3f8d",
+    "pixijs-scene-text/references/html-text.md": "07f90d0e08fdaa8a6650e931c583ab656c6d0b278bbc7747d43a4a87906212d8",
+    "pixijs-scene-text/references/split-bitmap-text.md": "8bd467a5a5daf2e1482dc846b741258260ef047c32c278063edefa08bb914abd",
+    "pixijs-scene-text/references/split-text.md": "6a57784c73c5d3ca10c6ecde9c90bb4f087d41728d86d836ff3503ed3677da27",
+    "pixijs-scene-text/references/text.md": "afbd3052b411d5bf2c6545d13573bbf1c5f0c8cd7ce394dd8ebb07a6ef9141f1",
+    "pixijs-ticker/SKILL.md": "f9831fff4604279e45fe6a605a244d5535fb2669e6f6a92a184d61e35b9b4a64"
+  },
+  "normalizations": {
+    "pixijs-custom-rendering/references/uniform-types.md": {
+      "originalSha256": "ab80615c39f48b9a340693cf677b48e86a7fb0c6ecf8d12be9155ea1e860e556",
+      "change": "Removed an extra trailing blank line; documentation content is unchanged."
+    }
+  }
+}

package/vendor/pixijs-skills/skills/pixijs/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: pixijs
+description: "Use this skill first for ANY PixiJS v8 task; it routes to the right specialized skill for the job. Covers the full PixiJS surface: Application setup, the scene graph (Container, Sprite, Graphics, Text, Mesh, ParticleContainer, DOMContainer, GifSprite), rendering (WebGL/WebGPU/Canvas, render loop, custom shaders, filters, blend modes), assets, events, color, math, ticker, accessibility, performance, environments, migration from v7, and project scaffolding. Triggers on: pixi, pixi.js, pixijs, PixiJS, v8, Application, app.init, Sprite, Container, Graphics, Text, Mesh, ParticleContainer, DOMContainer, GifSprite, Assets, Ticker, renderer, WebGL, WebGPU, scene graph, filter, shader, blend mode, texture, 3D texture, depth slice, layer, storage texture, BitmapText, create-pixi, how do I draw, how do I render, how do I animate in pixi."
+license: MIT
+---
+
+Entry point for the PixiJS v8 skill collection. PixiJS is the fastest library available for the web, working across all devices and allowing you to create rich, interactive graphics and cross-platform applications using WebGL, WebGPU, and Canvas as a fallback.
+
+## How to use this skill
+
+1. Find the specialized skill in the router below that best matches the task.
+2. Load that skill's `SKILL.md` and follow its guidance.
+3. If no sub-skill fits (the task references a specific class, function, option, or API surface not listed below), **WebFetch `https://pixijs.download/release/docs/llms.txt`**. That file is the auto-generated, always-current index of the full PixiJS API and guides. Each entry links to a `.html.md` page you can WebFetch for the detailed content.
+
+For the long-form description and trigger keywords of every skill, see [references/index.md](references/index.md).
+
+## Skill router
+
+### Foundations
+
+| Skill | Load when... |
+|---|---|
+| [pixijs-application](../pixijs-application/SKILL.md) | Creating or configuring a PixiJS `Application`, calling `app.init()`, accessing `app.stage`/`renderer`/`canvas`/`screen`, resize/ticker plugins, `app.destroy()`. |
+| [pixijs-core-concepts](../pixijs-core-concepts/SKILL.md) | Understanding the renderer pipeline, choosing WebGL/WebGPU/Canvas, render loop internals, systems and pipes, renderer loader extensions, rendering into a `RenderTexture`/`RenderTarget` (`flipY`, `mipLevel`, `layer`, `bind`/`push`/`pop`, depth) or a depth slice of a 3D texture, WebGL context loss and WebGPU device loss. |
+| [pixijs-create](../pixijs-create/SKILL.md) | Scaffolding a new project with the `create-pixi` CLI (bundler-vite, creation-web, framework-react templates), adding PixiJS to an existing project, or setting up `tsconfig.json` for TypeScript 5, 6, or 7 (`moduleResolution`, `@webgpu/types`, `@types/web`). |
+| [pixijs-environments](../pixijs-environments/SKILL.md) | Running PixiJS in Web Workers, Node/SSR, or strict-CSP contexts (`DOMAdapter`, `WebWorkerAdapter`, `pixi.js/unsafe-eval`). |
+| [pixijs-migration-v8](../pixijs-migration-v8/SKILL.md) | Upgrading from v7 to v8 or fixing v7 patterns (`beginFill`/`endFill`, `@pixi/*` packages, `BaseTexture`, `DisplayObject`). |
+| [pixijs-scene-core-concepts](../pixijs-scene-core-concepts/SKILL.md) | Understanding the scene graph as a whole: containers vs leaves, transforms, render order, masking, `RenderLayer`. |
+
+### Scene Objects
+
+| Skill | Load when... |
+|---|---|
+| [pixijs-scene-container](../pixijs-scene-container/SKILL.md) | Working with `Container`: `addChild`/`removeChild`, transforms, `zIndex`, bounds, `toGlobal`/`toLocal`, `destroy`. |
+| [pixijs-scene-sprite](../pixijs-scene-sprite/SKILL.md) | Drawing images: `Sprite`, `AnimatedSprite`, `NineSliceSprite`, `TilingSprite`. |
+| [pixijs-scene-graphics](../pixijs-scene-graphics/SKILL.md) | Drawing vector shapes or paths: `Graphics`, `GraphicsContext`, `fill`/`stroke`, `FillGradient`, `FillPattern`, `textureSpace`, texture and pattern fills, SVG import (`svg()`, gradients). |
+| [pixijs-scene-text](../pixijs-scene-text/SKILL.md) | Rendering text: `Text`, `BitmapText`, `HTMLText`, `SplitText`, `TextStyle`. |
+| [pixijs-scene-mesh](../pixijs-scene-mesh/SKILL.md) | Custom geometry: `Mesh`, `MeshSimple`, `MeshPlane`, `MeshRope`, `PerspectiveMesh`. |
+| [pixijs-scene-particle-container](../pixijs-scene-particle-container/SKILL.md) | Rendering thousands of lightweight sprites: `ParticleContainer`, `Particle`, `dynamicProperties`. |
+| [pixijs-scene-dom-container](../pixijs-scene-dom-container/SKILL.md) | Overlaying HTML elements on the canvas: `DOMContainer`, `pixi.js/dom`. |
+| [pixijs-scene-gif](../pixijs-scene-gif/SKILL.md) | Displaying animated GIFs: `GifSprite`, `GifSource`, `pixi.js/gif`. |
+| [pixijs-html-source](../pixijs-html-source/SKILL.md) | Rendering live HTML/DOM elements or snapshots as textures (experimental, needs a browser that supports the HTML-in-Canvas spec): `HTMLSource`, `ElementImageSource`, `pixi.js/html-source`, `requestPaint`. |
+
+### Utilities
+
+| Skill | Load when... |
+|---|---|
+| [pixijs-assets](../pixijs-assets/SKILL.md) | Loading resources: `Assets.init`, `Assets.load`, bundles, manifests, spritesheets, caching. |
+| [pixijs-color](../pixijs-color/SKILL.md) | Creating or converting colors: `Color` class, hex/rgb/hsl, `tint`, `premultiply`. |
+| [pixijs-events](../pixijs-events/SKILL.md) | Handling pointer/mouse/touch/wheel input: `eventMode`, `FederatedEvent`, `hitArea`, `cursor`, drag. |
+| [pixijs-math](../pixijs-math/SKILL.md) | Points, vectors, matrices, shapes, hit testing: `Point`, `Matrix`, `Rectangle`, `Polygon`, `Triangle`, `strokeContains`, `containsRect`, `Matrix.decompose` (mirrored matrices), `toGlobal`/`toLocal`. |
+| [pixijs-ticker](../pixijs-ticker/SKILL.md) | Per-frame logic or controlling the render loop: `Ticker`, `deltaTime`, `UPDATE_PRIORITY`, `maxFPS`. |
+
+### Advanced
+
+| Skill | Load when... |
+|---|---|
+| [pixijs-accessibility](../pixijs-accessibility/SKILL.md) | Screen reader or keyboard navigation: `AccessibilitySystem`, `accessibleTitle`, `tabIndex`. |
+| [pixijs-blend-modes](../pixijs-blend-modes/SKILL.md) | Compositing with blend modes: `add`, `multiply`, `screen`, `overlay`, `pixi.js/advanced-blend-modes`. |
+| [pixijs-custom-rendering](../pixijs-custom-rendering/SKILL.md) | Writing custom shaders, uniforms, or batchers: `Shader.from`, `GlProgram`/`GpuProgram`, `UniformGroup`, custom `Filter`, WGSL `override` constants, `gpuLayout`, `TextureView`, `Buffer.update`, `TexturePool`, 3D/array textures, storage textures, render bundles, custom pipes. |
+| [pixijs-filters](../pixijs-filters/SKILL.md) | Applying visual effects: `BlurFilter`, `ColorMatrixFilter`, `DisplacementFilter`, `Filter.from`, `pixi-filters`. |
+| [pixijs-performance](../pixijs-performance/SKILL.md) | Profiling or optimizing FPS, draw calls, GPU memory: culling, `GCSystem`, `cacheAsTexture`, object pooling, transient MSAA render textures, render bundles, filter texture sizing. |
+
+## Fallback: canonical PixiJS docs
+
+If the task references a class, function, option, or API surface not covered by any sub-skill above, **WebFetch `https://pixijs.download/release/docs/llms.txt`**. It's the auto-generated index of the full PixiJS API and guides, regenerated on every release. Each entry links to a `.html.md` page you can WebFetch for the detailed content. Use this fallback whenever the router table doesn't point at an obvious match.

package/vendor/pixijs-skills/skills/pixijs/references/index.md

@@ -0,0 +1,136 @@
+# PixiJS Skills: Full Index
+
+Detailed routing table for the PixiJS v8 skill collection. Each entry lists the skill's full description and the trigger keywords that should match it. For a scannable short-form table, see the parent `SKILL.md`.
+
+## Foundations
+
+### pixijs-application
+Create and configure a PixiJS v8 `Application`. Covers `new Application()` + async `app.init()` options (width, height, background, antialias, resolution, autoDensity, preference, resizeTo, autoStart, sharedTicker, canvas), `app.stage`/`renderer`/`canvas`/`screen` access, `ResizePlugin`, `TickerPlugin`, and `app.destroy()`.
+
+**Triggers:** Application, app.init, app.stage, app.renderer, app.canvas, app.screen, ApplicationOptions, resizeTo, preference, autoStart, sharedTicker, app.destroy.
+
+### pixijs-core-concepts
+How PixiJS v8 renders frames: the systems-and-pipes renderer, the render loop, and how the library adapts to different environments. Covers `WebGLRenderer`/`WebGPURenderer`/`CanvasRenderer` selection, `renderer.render()` pipeline, environment detection, and pointers to per-topic deep dives.
+
+**Triggers:** renderer, WebGL, WebGPU, Canvas, render loop, render pipeline, systems, environments, autoDetectRenderer, RenderTexture, RenderTarget, render to texture, flipY, mipLevel, layer, 3D texture, depth slice, renderTarget.bind, copyToTexture, copyDepthTexture, depth-only, WebGLLoader, WebGPULoader, CanvasLoader, RendererLoader, lazy-load renderer systems, context lost, webglcontextlost, device lost, GPUDevice.lost.
+
+### pixijs-create
+Scaffold a new PixiJS v8 project with the `create-pixi` CLI or add PixiJS to an existing project. Covers npm/yarn/pnpm/bun create commands, interactive vs non-interactive flows, available template presets (bundler-vite, bundler-webpack, bundler-esbuild, bundler-import-map, creation-web, framework-react, extension-default), Node version requirements, TypeScript 5/6/7 tsconfig setup (`moduleResolution`, `@webgpu/types`, `@types/web`), and post-scaffold dev flow.
+
+**Triggers:** create pixi.js, npm create, scaffold, template, bundler-vite, bundler-webpack, creation-web, framework-react, new project, getting started, TypeScript, tsconfig, moduleResolution, @webgpu/types, @types/web, Cannot find name GPUTextureUsage.
+
+### pixijs-environments
+Run PixiJS v8 outside a standard browser: Web Workers, `OffscreenCanvas`, Node/SSR, or CSP-restricted contexts. Covers `DOMAdapter.set`, `BrowserAdapter`, `WebWorkerAdapter`, custom `Adapter` interface, `pixi.js/unsafe-eval` for strict CSP.
+
+**Triggers:** DOMAdapter, BrowserAdapter, WebWorkerAdapter, Web Worker, OffscreenCanvas, Node, headless, SSR, CSP, unsafe-eval, Adapter.
+
+### pixijs-migration-v8
+Upgrade a PixiJS project from v7 to v8 or diagnose broken v7 code after an upgrade. Covers async `app.init`, single `pixi.js` package (deprecated `@pixi/*` sub-packages), `Graphics` shape-then-fill, `BaseTexture` -> `TextureSource`, shader/uniform rework, `ParticleContainer`+`Particle`, constructor options objects, `DisplayObject` removal, `settings`/`utils` removal, `Ticker` signature, events rewrite.
+
+**Triggers:** migrate v7, v8 breaking changes, @pixi/ import, DisplayObject, beginFill, endFill, cacheAsBitmap, BaseTexture, deprecated.
+
+### pixijs-scene-core-concepts
+The PixiJS v8 scene graph as a whole: how containers, leaves, transforms, and render order fit together. Covers leaf vs container distinction, local/world coordinates, culling, render groups, sortable children, masking, `RenderLayer`, and which leaf skill covers which display object.
+
+**Triggers:** scene graph, display list, Container, Sprite, Graphics, Text, Mesh, ParticleContainer, DOMContainer, GifSprite, masking, mask texture destroyed, MaskFilter, render group, RenderLayer, world transform.
+
+## Scene Objects
+
+### pixijs-scene-container
+Group, position, or transform display objects. Covers `Container` constructor options (`isRenderGroup`, `sortableChildren`, `boundsArea`), `addChild`/`removeChild`/`addChildAt`/`swapChildren`/`setChildIndex`, `position`/`scale`/`rotation`/`pivot`/`skew`/`alpha`/`tint`, `getBounds`/`getGlobalPosition`/`toLocal`/`toGlobal`, `zIndex` sorting, `cullable`, `destroy`.
+
+**Triggers:** Container, addChild, removeChild, addChildAt, swapChildren, sortableChildren, zIndex, position, scale, rotation, pivot, getBounds, toGlobal, toLocal, destroy.
+
+### pixijs-scene-dom-container
+Overlay HTML elements on the PixiJS v8 canvas. Covers `DOMContainer` with `element`, `anchor`, and scene-graph-driven CSS transforms, the `pixi.js/dom` side-effect import, `DOMPipe` registration, visibility sync, pointer-events handling.
+
+**Triggers:** DOMContainer, pixi.js/dom, DOMPipe, HTML overlay, input on canvas, iframe overlay, DOMContainerOptions, element, anchor.
+
+### pixijs-scene-gif
+Display animated GIFs. Covers the `pixi.js/gif` side-effect import, `Assets.load` returning a `GifSource`, `GifSprite` playback (`play`/`stop`/`currentFrame`/`animationSpeed`), `autoPlay`/`loop` options, `onComplete`/`onLoop`/`onFrameChange` callbacks, `GifSource` sharing, `clone`, `destroy`.
+
+**Triggers:** GifSprite, GifSource, pixi.js/gif, animationSpeed, currentFrame, autoPlay, onComplete, onFrameChange.
+
+### pixijs-html-source
+Render live HTML/DOM elements or frozen snapshots as PixiJS v8 textures via the HTML-in-Canvas browser APIs. Experimental: requires a browser that supports the HTML-in-Canvas spec (the API must be enabled, or the texture uploader throws on first render). Covers the `pixi.js/html-source` side-effect import, feature detection with `canvas.requestPaint`, `HTMLSource` for a live repainting element (`autoLayout`/`autoUpdate`/`autoRequestPaint`, `requestPaint`, `isReady`, the direct-child-of-canvas + `layoutsubtree` rule), `ElementImageSource` for an immutable `captureElementImage()` snapshot (`autoClose`, ready immediately), using the source on a `Sprite`/`Texture`/`Mesh`, and fallback-only auto-detection via `Texture.from`.
+
+**Triggers:** HTMLSource, ElementImageSource, pixi.js/html-source, requestPaint, captureElementImage, ElementImage, layoutsubtree, autoRequestPaint, autoClose, HTML in canvas, HTML-in-Canvas, render DOM to texture, render HTML to texture, HTMLSourceCanvas, texElementImage2D, copyElementImageToTexture, experimental.
+
+### pixijs-scene-graphics
+Draw vector shapes and paths. Covers the `Graphics` shape-then-fill API (`rect`/`circle`/`ellipse`/`poly`/`roundRect`/`star`), path methods (`moveTo`/`lineTo`/`bezierCurveTo`/`arc`), `fill`/`stroke`/`cut`, `FillGradient`, `FillPattern`, `GraphicsContext` sharing, SVG markup.
+
+**Triggers:** Graphics, GraphicsContext, rect, circle, poly, roundRect, fill, stroke, cut, FillGradient, FillPattern, FillPatternOptions, textureSpace, pattern fill, texture fill, spritesheet fill, radialGradient, linearGradient, svg gradient, moveTo, bezierCurveTo, svg.
+
+### pixijs-scene-mesh
+Render custom geometry. Covers `Mesh` with `MeshGeometry` (positions, uvs, indices, topology), `MeshSimple` for per-frame vertex animation, `MeshPlane` for subdivided deformation, `MeshRope` for path-following textures, `PerspectiveMesh` for 2.5D corners.
+
+**Triggers:** Mesh, MeshGeometry, MeshSimple, MeshPlane, MeshRope, PerspectiveMesh, positions, uvs, indices, topology, setCorners.
+
+### pixijs-scene-particle-container
+Render thousands of lightweight sprites. Covers `ParticleContainer` with `Particle` instances, `addParticle`/`removeParticle`, `particleChildren` array, `dynamicProperties` (vertex, position, rotation, uvs, color), `boundsArea`, `roundPixels`, `update`.
+
+**Triggers:** ParticleContainer, Particle, IParticle, addParticle, particleChildren, dynamicProperties, boundsArea, particle effects, particle alpha, particle tint, fade particles.
+
+### pixijs-scene-sprite
+Draw images. Covers `Sprite` with `anchor`/`tint`/`texture`, `AnimatedSprite` for frame animation, `NineSliceSprite` for resizable UI panels, `TilingSprite` for scrolling/repeating backgrounds.
+
+**Triggers:** Sprite, AnimatedSprite, NineSliceSprite, TilingSprite, Sprite.from, anchor, tint, tilePosition, animationSpeed, gotoAndPlay, leftWidth, topHeight.
+
+### pixijs-scene-text
+Render text. Covers `Text` for canvas-quality styled labels, `BitmapText` for cheap per-frame updates via glyph atlas, `HTMLText` for HTML/CSS markup via SVG, `SplitText` and `SplitBitmapText` for per-character animation, `TextStyle`, `tagStyles`.
+
+**Triggers:** Text, BitmapText, HTMLText, SplitText, SplitBitmapText, TextStyle, HTMLTextStyle, BitmapFont.install, tagStyles, fontFamily, wordWrap, textureStyle, scaleMode, context loss.
+
+## Utilities
+
+### pixijs-assets
+Load and manage resources. Covers `Assets.init`, `Assets.load`/`add`/`unload`, bundles, manifests, background loading, `onProgress`, caching, spritesheets, compressed textures, SVG as texture or Graphics, resolution detection.
+
+**Triggers:** Assets, Assets.load, Assets.init, loadBundle, manifest, backgroundLoad, Spritesheet, Cache, LoadOptions, unload, svg, loadSvg, parseAsGraphicsContext, svg gradient.
+
+### pixijs-color
+Create, convert, or manipulate colors. Covers `Color` class input formats (hex, CSS names, RGB/HSL objects, arrays, `Uint8Array`), conversion methods (`toHex`, `toNumber`, `toArray`, `toRgba`), component access, `setAlpha`/`multiply`/`premultiply`, `Color.shared` singleton.
+
+**Triggers:** Color, ColorSource, hex, rgb, hsl, tint, premultiply, Color.shared, color conversion.
+
+### pixijs-events
+Handle pointer, mouse, touch, or wheel input. Covers `eventMode` (none, passive, auto, static, dynamic), `FederatedEvent` types, propagation and capture phase, `hitArea`, `interactiveChildren`, `cursor` and `cursorStyles`, global move events for drag, `eventFeatures` config.
+
+**Triggers:** eventMode, FederatedPointerEvent, pointerdown, click, tap, globalpointermove, drag, hitArea, cursor, stopPropagation, persistentDeviceId.
+
+### pixijs-math
+Coordinates, vectors, matrices, shapes, and hit testing. Covers `Point`/`ObservablePoint`, `Matrix` (2D affine, decompose, apply), shapes (`Rectangle`, `Circle`, `Ellipse`, `Polygon`, `RoundedRectangle`, `Triangle`), `toGlobal`/`toLocal`, `PointData` types, `DEG_TO_RAD`, and `pixi.js/math-extras` vector helpers.
+
+**Triggers:** Point, ObservablePoint, Matrix, Rectangle, Circle, Polygon, Triangle, RoundedRectangle, strokeContains, containsRect, intersects, isClockwise, winding order, stroke hit test, decompose, mirror, flip, negative scale, setFromMatrix, toGlobal, toLocal, hitArea, math-extras, DEG_TO_RAD, PointData.
+
+### pixijs-ticker
+Run per-frame logic or control the render loop. Covers `Ticker.add`/`addOnce`/`remove`, `deltaTime` vs `deltaMS` vs `elapsedMS`, `UPDATE_PRIORITY` ordering, `maxFPS`/`minFPS` capping, speed scaling, `Ticker.shared` vs new instances, per-object `onRender` hook, manual rendering.
+
+**Triggers:** Ticker, UPDATE_PRIORITY, deltaTime, deltaMS, elapsedMS, onRender, app.ticker, maxFPS, minFPS, Ticker.shared.
+
+## Advanced
+
+### pixijs-accessibility
+Add screen reader and keyboard navigation to PixiJS v8 apps. Covers `AccessibilitySystem` options (`enabledByDefault`, `debug`, `activateOnTab`, `deactivateOnMouseMove`), per-container accessibility properties, shadow DOM overlay, mobile touch-hook activation.
+
+**Triggers:** accessibility, a11y, screen reader, ARIA, keyboard navigation, tab order, AccessibilitySystem, accessibleTitle, accessibleHint, tabIndex, accessibleChildren.
+
+### pixijs-blend-modes
+Composite display objects with blend modes. Covers standard modes (`normal`, `add`, `multiply`, `screen`, `erase`, `min`, `max`), advanced modes via `pixi.js/advanced-blend-modes` (`color-burn`, `overlay`, `hard-light`, etc.), batch-friendly ordering.
+
+**Triggers:** blendMode, additive, multiply, screen, overlay, color-burn, color-dodge, advanced-blend-modes, glow, erase.
+
+### pixijs-custom-rendering
+Write custom shaders, uniforms, or batchers. Covers `Shader.from({gl, gpu, resources})`, `GlProgram`/`GpuProgram`, `UniformGroup` with typed uniforms (`f32`, `vec2`, `mat4x4`), UBO mode, textures as resources, 3D and array textures, WebGPU storage textures, custom `Filter`, custom `Batcher` via extensions.
+
+**Triggers:** Shader, GlProgram, GpuProgram, UniformGroup, Batcher, Filter, GLSL, WGSL, UBO, uniform, custom shader, ShaderOverrides, gpuLayout, bind group layout, TextureView, depth texture, 3D texture, sampler3D, texture_3d, storage texture, Buffer.update, vertexCount, indexCount, getSize, clockwiseFrontFace, cullMode, render bundle, beginBundle, executeBundle, RenderBundle, TexturePool, getOptimalTexture, InstructionPipe, destroyInstructionSet.
+
+### pixijs-filters
+Apply visual effects to containers via the filter pipeline. Covers built-in filters (`AlphaFilter`, `BlurFilter`, `ColorMatrixFilter`, `DisplacementFilter`, `NoiseFilter`), custom `Filter.from()` with GLSL/WGSL, options (`resolution`, `padding`, `antialias`, `blendRequired`), `filterArea` optimization, `pixi-filters` community package.
+
+**Triggers:** filters, BlurFilter, ColorMatrixFilter, DisplacementFilter, NoiseFilter, Filter.from, GLSL filter, pixi-filters, filterArea.
+
+### pixijs-performance
+Profile or optimize a PixiJS v8 app for FPS, draw calls, or GPU memory. Covers destroy patterns (`cacheAsTexture(false)`, `releaseGlobalResources`), `GCSystem` and `TextureGCSystem`, `PrepareSystem`, object pooling, batching rules, `BitmapText` for dynamic text, culling (`Culler`, `CullerPlugin`, `cullable`, `cullArea`), resolution/antialias tradeoffs.
+
+**Triggers:** FPS, jank, draw calls, batching, object pool, GCSystem, PrepareSystem, Culler, cacheAsTexture, memory leak, destroy patterns, render bundle, transient, MSAA, Buffer.update, WebGPU performance, TexturePool, repeatEdgePixels, bind group.