mvtt

Use this skill when adding 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 on: accessibility, a11y, screen reader, ARIA, keyboard navigation, tab order, AccessibilitySystem, accessibleTitle, accessibleHint, tabIndex, accessibleChildren.

Use this skill when creating and configuring a PixiJS v8 Application. Covers new Application() + async app.init() options (width, height, background, antialias, resolution, autoDensity, preference, resizeTo, autoStart, sharedTicker, canvas, useBackBuffer, powerPreference, eventFeatures, accessibilityOptions, gcActive, bezierSmoothness, webgl/webgpu/canvasOptions per-renderer overrides), app.stage/renderer/canvas/screen/domContainerRoot access, ResizePlugin, TickerPlugin, CullerPlugin (cullable, cullArea), custom ApplicationPlugin creation via ExtensionType.Application, start/stop lifecycle, and app.destroy() with releaseGlobalResources. Triggers on: Application, app.init, app.stage, app.renderer, app.canvas, app.screen, app.domContainerRoot, ApplicationOptions, ApplicationPlugin, ExtensionType.Application, resizeTo, preference, autoStart, sharedTicker, useBackBuffer, powerPreference, skipExtensionImports, preferWebGLVersion, preserveDrawingBuffer, cullable, CullerPlugin, app.start, app.stop, app.destroy, rele

Use this skill when loading and managing resources in PixiJS v8. Covers Assets.init, Assets.load/add/unload, bundles, manifests, background loading, onProgress, caching, spritesheets, video textures, web fonts, bitmap fonts, animated GIFs, compressed textures, SVG as texture or Graphics, resolution detection, per-asset data options, and forcing a specific loader with the parser field (for extension-less URLs). Triggers on: Assets, Assets.load, Assets.init, loadBundle, manifest, backgroundLoad, Spritesheet, Cache, LoadOptions, unload, parser, loadParser, loadWebFont, loadBitmapFont, loadVideoTextures, GifSource, VideoSourceOptions.

Use this skill when compositing display objects with blend modes in PixiJS v8. 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 on: blendMode, additive, multiply, screen, overlay, color-burn, color-dodge, advanced-blend-modes, glow, erase.

Use this skill when creating, converting, or manipulating colors in PixiJS v8. 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 on: Color, ColorSource, hex, rgb, hsl, tint, premultiply, Color.shared, color conversion.

Use this skill when understanding 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 on: renderer, WebGL, WebGPU, Canvas, render loop, render pipeline, systems, environments, autoDetectRenderer.

Use this skill when scaffolding a new PixiJS v8 project with the create-pixi CLI or adding PixiJS to an existing project. Covers npm/yarn/pnpm/bun create commands, interactive vs non-interactive flows, bundler vs creation template categories, available template presets (bundler-vite, bundler-webpack, bundler-esbuild, bundler-import-map, creation-web, framework-react, extension-default), Node version requirements, `npm install pixi.js` for existing projects, post-scaffold dev flow, and the Vite top-level-await production-build gotcha. Triggers on: create pixi.js, npm create, npm install pixi.js, scaffold, template, bundler-vite, bundler-webpack, creation-web, framework-react, new project, existing project, getting started, quick start.

Use this skill when writing custom shaders, uniforms, filters, or batchers in PixiJS v8. Covers Shader.from({gl, gpu, resources}), GlProgram/GpuProgram, UniformGroup with typed uniforms (f32, vec2, mat4x4), UBO mode, textures as resources, custom Filter via Filter.from, GLSL ES 3.0 conventions (in/out, finalColor, texture()), uBackTexture sampling, pixi.js/unsafe-eval for strict CSP, custom Batcher via extensions. Triggers on: Shader, GlProgram, GpuProgram, UniformGroup, Batcher, Filter, Filter.from, GLSL, WGSL, UBO, uniform, custom shader, finalColor, uBackTexture, blendRequired, unsafe-eval.

Use this skill when running 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 on: DOMAdapter, BrowserAdapter, WebWorkerAdapter, Web Worker, OffscreenCanvas, Node, headless, SSR, CSP, unsafe-eval, Adapter.

Use this skill when handling pointer, mouse, touch, or wheel input in PixiJS v8. 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 on: eventMode, FederatedPointerEvent, pointerdown, click, tap, globalpointermove, drag, hitArea, cursor, stopPropagation.

Use this skill when applying visual effects to PixiJS v8 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 on: filters, BlurFilter, ColorMatrixFilter, DisplacementFilter, NoiseFilter, Filter.from, GLSL filter, pixi-filters, filterArea.

Use this skill when working with coordinates, vectors, matrices, shapes, hit testing, or layout rectangles in PixiJS v8. Covers Point/ObservablePoint, Matrix (2D affine, decompose, apply, applyInverse), shapes (Rectangle, Circle, Ellipse, Polygon, RoundedRectangle, Triangle), Rectangle layout helpers (pad, fit, enlarge, ceil, scale, getBounds), strokeContains hit tests, Polygon isClockwise/containsPolygon, toGlobal/toLocal, PointData/PointLike/Size types, DEG_TO_RAD, and pixi.js/math-extras vector and intersection helpers. Triggers on: Point, ObservablePoint, Matrix, Rectangle, Circle, Polygon, Triangle, RoundedRectangle, toGlobal, toLocal, hitArea, strokeContains, pad, fit, enlarge, ceil, getBounds, containsRect, intersects, isClockwise, math-extras, lineIntersection, segmentIntersection, DEG_TO_RAD, PointData.

Use this skill when upgrading to PixiJS v8 from v7 or diagnosing 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 on: migrate v7, v8 breaking changes, @pixi/ import, DisplayObject, beginFill, endFill, cacheAsBitmap, BaseTexture, deprecated.

Use this skill when profiling or optimizing 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 on: FPS, jank, draw calls, batching, object pool, GCSystem, PrepareSystem, Culler, cacheAsTexture, memory leak, destroy patterns.

Use this skill when reasoning about 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, constructor options shared by every scene node, and which leaf skill covers which display object. Triggers on: scene graph, display list, Container, Sprite, Graphics, Text, Mesh, ParticleContainer, DOMContainer, GifSprite, masking, render group, RenderLayer, world transform, constructor options, ContainerOptions.

Use this skill when overlaying 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 on: DOMContainer, pixi.js/dom, DOMPipe, HTML overlay, input on canvas, iframe overlay, DOMContainerOptions, element, anchor, constructor options.

Use this skill when displaying animated GIFs in PixiJS v8. 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 on: GifSprite, GifSource, pixi.js/gif, animationSpeed, currentFrame, autoPlay, onComplete, onFrameChange, constructor options, GifSpriteOptions.

Use this skill when drawing vector shapes and paths in PixiJS v8. Covers the Graphics API: shape-then-fill methods (rect/circle/ellipse/poly/roundRect/star/regularPoly/roundPoly/roundShape/filletRect/chamferRect), path methods (moveTo/lineTo/bezierCurveTo/quadraticCurveTo/arc/arcTo/arcToSvg/closePath), fill/stroke/cut, holes, FillGradient (linear/radial), FillPattern, GraphicsContext sharing, svg import/export, containsPoint hit testing, cloning, clearing, bounds, fillStyle/strokeStyle, draw-time transforms (rotateTransform/scaleTransform/translateTransform/setTransform/save/restore), default styles, GraphicsPath reuse. Triggers on: Graphics, GraphicsContext, rect, circle, poly, roundRect, fill, stroke, cut, hole, beginHole, FillGradient, FillPattern, moveTo, bezierCurveTo, svg, graphicsContextToSvg, svg export, GraphicsOptions, containsPoint, clone, clear, bounds, rotateTransform, translateTransform, setFillStyle, setStrokeStyle, GraphicsPath.

Use this skill when rendering custom geometry in PixiJS v8. 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 on: Mesh, MeshGeometry, MeshSimple, MeshPlane, MeshRope, PerspectiveMesh, positions, uvs, indices, topology, setCorners, constructor options, MeshOptions, MeshPlaneOptions, MeshRopeOptions, SimpleMeshOptions, PerspectivePlaneOptions.

Use this skill when rendering thousands of lightweight sprites in PixiJS v8. Covers ParticleContainer with Particle instances, addParticle/removeParticle, particleChildren array, dynamicProperties (vertex, position, rotation, uvs, color), boundsArea, roundPixels, update. Triggers on: ParticleContainer, Particle, IParticle, addParticle, particleChildren, dynamicProperties, boundsArea, particle effects, constructor options, ParticleContainerOptions, ParticleOptions.

Use this skill when drawing images in PixiJS v8. Covers Sprite with anchor/tint/texture, AnimatedSprite for frame animation, NineSliceSprite for resizable UI panels, TilingSprite for scrolling/repeating backgrounds. Triggers on: Sprite, AnimatedSprite, NineSliceSprite, TilingSprite, Sprite.from, anchor, tint, tilePosition, animationSpeed, gotoAndPlay, leftWidth, topHeight, constructor options, SpriteOptions, AnimatedSpriteOptions, NineSliceSpriteOptions, TilingSpriteOptions.

Use this skill when rendering text in PixiJS v8. 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, constructor options, TextOptions, HTMLTextOptions, BitmapText, SplitTextOptions, SplitBitmapTextOptions. Triggers on: Text, BitmapText, HTMLText, SplitText, SplitBitmapText, TextStyle, HTMLTextStyle, BitmapFont.install, tagStyles, fontFamily, wordWrap.

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, BitmapText, create-pixi, how do I draw, how do I render, how do I animate in pixi.

Use this skill when running per-frame logic or controlling the PixiJS v8 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 on: Ticker, UPDATE_PRIORITY, deltaTime, deltaMS, elapsedMS, onRender, app.ticker, maxFPS, minFPS, Ticker.shared.

Domain Driven Design guidance for TypeScript/Deno codebases. Apply when writing or modifying code to choose appropriate DDD building blocks (entities, value objects, aggregates, domain services, repositories) and maintain ubiquitous language. Triggers on all code changes to ensure domain model consistency.

Use this skill to write or fix a dice formula string for the `@dice-roller/rpg-dice-roller` parser. Trigger whenever a user describes any tabletop RPG roll, mechanic, attack, save, check, damage, pool, or resolution and wants the single-string expression back — whether they say "notation", "formula", "dice string", "the roll for X", name the library, or just describe the mechanic. Trigger for any system: D&D, Pathfinder, FATE/Fudge, Storyteller/WoD/Vampire, Shadowrun, Cypher, Year Zero, Savage Worlds, PbtA, Burning Wheel, homebrew. Trigger for any dice idiom: advantage/disadvantage, exploding/compound/penetrating dice, drop/keep, pools with target successes and botches, rerolls, clamps, crit/fumble, roll groups, arithmetic on rolls. Also trigger when wiring a rolled trait, component, server call, or schema field whose value is such a formula. Do NOT trigger for the library's JS API (DiceRoll/DiceRoller classes), probability analysis, result storage/UI, or rules-lookup questions that don't end in a formula.

Entity-Component-System (ECS) guidance for the mvtt live game World and the plugins that extend it. Apply when writing or modifying code inside any @vtt/* plugin that contributes traits, events, commands, systems, views, sentinel entities, or pattern helpers (factories) to the World. Use alongside the ddd skill — ECS structures the contents of the World aggregate; DDD structures everything else (substrate, persistence, content catalogs, orchestration).

Write set design — Courtney Campbell's room-keying technique from the Hack & Slash blog — directly into a note page. Use this skill whenever the user wants to key a dungeon room, scene, adventure location, encounter area, NPC interaction, or any other place where players might walk in and look around. Emits a ```setdesign fenced block; the notes plugin renders it as a structured tree with bold visible elements, italic stats, arrow connectors, and wiki-link chips for characters/scenes/assets. Trigger when the user says "set design", "set dress", "key this room", "set up this scene", mentions Hack & Slash or Courtney Campbell, or asks for a scannable at-the-table reference for an adventure location.

Use this skill when authoring or organizing components in Solid (SolidJS): the run-once lifecycle, capital-letter naming (lowercase is parsed as a DOM tag), default vs named exports, distinguishing the component **function** from the JSX it returns, and choosing the right TypeScript component type. Covers `Component<P>` (default, no children), `ParentComponent<P>` (`children?` included), `VoidComponent<P>` (children explicitly forbidden), `FlowComponent<P, T>` (children of a specific JSX shape, used by `<Show>`, `<For>`, etc.), generic components (must be a function declaration, not the `Component` type), and conditional rendering inside the return statement. Triggers on: component, function component, capital letter, Component<>, ParentComponent, VoidComponent, FlowComponent, generic component, component lifecycle, Solid component.

Use this skill when configuring a Solid (SolidJS) project: `tsconfig.json` for JSX, `vite.config.ts` (or `vitest.config.ts` for tests) with `vite-plugin-solid`, environment variables (Vite's `VITE_*` for client-exposed, server-only otherwise), `.env` files and modes, `app.config.ts` in SolidStart (Vinxi), and bundler integration with other tools. Covers required tsconfig keys (`jsx: "preserve"`, `jsxImportSource: "solid-js"`), vite-plugin-solid options (`hot`, `ssr`, `solid`, `babel`, `typescript`, `extensions`), the env-var rule (Vite exposes only `VITE_*` to the client; everything else is server-only and tree-shaken), how `import.meta.env` works, and SolidStart-specific config in `app.config.ts` (presets, ssr toggle, middleware path, vite plugin pass-through). Triggers on: vite-plugin-solid, vite.config, tsconfig, jsx preserve, jsxImportSource, env vars, VITE_, .env, .env.production, app.config, app.config.ts, vinxi, build configuration, deployment preset, NODE_ENV, mode, importmeta env.

Use this skill when sharing data across a Solid (SolidJS) component tree without prop drilling: theme, current user, i18n, design-system tokens, anything that many components in a subtree need. Covers `createContext` (with optional default value to avoid `| undefined`), `<MyContext.Provider value={...}>` to scope the data, `useContext` to read it (returns the default if no Provider, or `undefined` if no default), the standard pattern of putting **signals or stores** into context (not raw values, so consumers see updates), custom Provider components for ergonomics, custom `useMyContext()` hooks that throw on missing Provider for crisp error messages, typing context with `ReturnType<typeof factoryFn>`, and the rule that components above a Provider don't see its value. Triggers on: createContext, useContext, Provider, context API, prop drilling, theme, current user, i18n, shared state, useMyContext, custom hook.

Use this skill for any conditional rendering, list iteration, dynamic component, portal, error boundary, suspense, or async lazy-loading in Solid (SolidJS). Covers `<Show>` (truthy-conditional with `fallback`, optional `keyed`, function-child accessor for type narrowing), `<Switch>`+`<Match>` (multi-branch, sequential evaluation, optional `fallback`), `<For>` (keyed-by-reference list, `index` is a signal, re-uses DOM nodes when items move), `<Index>` (keyed-by-position list, `item` is a signal, ideal for primitives and stable-length arrays), `<Dynamic>` and `createDynamic` (component selected at runtime), `<Portal>` (mount outside DOM hierarchy, events propagate via component tree), `<ErrorBoundary>` (catches render-time errors, fallback can use `(err, reset)` form), `<Suspense>` (waits for resources, integrates with `createResource`), `<SuspenseList>` (orchestrates multiple Suspenses), `lazy()` (code-split with `.preload()`), and `<NoHydration>` (skip hydration of a subtree). The For-vs-Index decision rule.

Use this skill when running side effects in Solid (SolidJS): logging, DOM manipulation, network requests, subscriptions, intervals, anything triggered by reactive state changes. Covers `createEffect` (re-runs whenever a tracked signal changes), `onMount` (one-time setup after mount, never re-runs), `onCleanup` (runs when the owner is disposed — component unmount, effect re-run, root dispose), automatic batching of writes inside effects, nested effects (each has its own dependency tree), why writing to signals from inside an effect is usually wrong (use a memo instead), and effect ordering. Triggers on: createEffect, onMount, onCleanup, side effect, lifecycle, useEffect equivalent, cleanup, subscribe, interval, timer, dispose, unmount.

Use this skill when handling user input or DOM events in Solid (SolidJS): pointer/mouse/keyboard/form/touch events, custom events, capture-phase listeners, listener options. Covers Solid's two event systems — **delegated** (`onClick`, `onInput`, ...) attached at the document and dispatched on bubble, vs **native** (`on:click`, `on:my-event`) attached directly to the element — when each is appropriate, the case-sensitivity rule (delegated is case-insensitive, native is case-sensitive), the array binding form `onClick={[handler, data]}` for cheap currying, the full list of delegated events, the `stopPropagation` gotcha (delegated events listen at the document so `stopPropagation()` on a parent is too late), how Portals propagate events through the component tree (not the DOM tree), and the listener-options object for `once`/`passive`/`capture`/`signal`. Triggers on: event handler, onClick, onInput, on:, on*, event delegation, stopPropagation, custom event, on:custom-event, listener options, once, passive, captu

Use this skill for any non-event JSX attribute in Solid (SolidJS) — what each one does, how it merges, when to use which prefix. Covers `class` (preferred over deprecated `className`), `classList` (object of `{ name: bool }`, applied per-class), `style` (string or kebab-case object including CSS variables `--my-var`), `ref` (variable or callback), the namespace prefixes `attr:*` (force HTML attribute), `prop:*` (force DOM property — preserves objects/arrays), `bool:*` (boolean attribute), `on:*` (native event, case-sensitive), `on*` (delegated event), `oncapture:*` (deprecated capture form), `use:*` (custom directive), and content attributes `innerHTML`, `textContent`, `innerText`. Also: when reactive `class` and `classList` conflict, the SSR merge behavior, and the special `once` flag in `on:` listener options. Triggers on: classList, class, style, ref, attr:, prop:, bool:, innerHTML, textContent, innerText, JSX attributes, jsx-attributes, kebab case style, CSS variables in JSX, on:, oncapture:, use:.

Use this skill when writing or debugging JSX in Solid (SolidJS): single-root requirement, self-closing tags, dynamic expressions in `{ }`, the difference between HTML attributes and JSX properties, fragments (`<>...</>`), inline styles requiring `{{ }}` (object) or `{`...`}` (string), the order in which expressions are applied to elements (matters for `<input type="range">`), event handler casing, and how Solid compiles JSX into DOM operations directly (no virtual DOM). Triggers on: JSX, fragment, single root, self-closing, expression, JSX in Solid, properties vs attributes, inline style, JSX compiles, DOM nodes, double curly braces.

Use this skill when caching a derived/computed value in Solid (SolidJS) with `createMemo`. Covers the difference between a plain derived function (recomputes on every read) and a memo (caches and only recomputes when dependencies change), the `equals` option (default `===`, `false` to always notify, custom comparator), the `value` parameter for the initial `prev`, accessing the previous value (`(prev) => ...`), the `name` debug option, and the decision rule: prefer plain `() => derive()` and only reach for `createMemo` when the computation is expensive, when many places will read it, or when you need custom equality. Triggers on: createMemo, memo, derived value, computed, cache, memoize, equals, custom equality.

Use this skill when reasoning about why Solid (SolidJS) code is or is not updating, or before any non-trivial Solid task. Covers Solid's core philosophy: components run **once**, reactivity is **fine-grained**, signals are **getter functions**, props are a **reactive proxy** that must not be destructured, JSX placement determines what is reactive, and tracking scopes (`createEffect`/`createMemo`/JSX) are the only places where signals subscribe. Explains the owner tree, the difference between signals and stores, and why mutating without going through a setter is a no-op. **Almost every Solid bug is a violation of one of these principles** — start here whenever something isn't updating, an effect runs too often or not at all, or you find yourself wishing for a `useEffect`. Triggers on: mental model, fine-grained reactivity, components run once, tracking scope, owner, why isn't this updating, signal vs store, reactive system, Solid philosophy, why doesn't my effect run, why does my prop look stale, destructure p

Use this skill when setting `<head>` tags reactively in Solid (SolidJS) — page title, meta description, canonical link, OpenGraph/Twitter cards, theme color, RSS feed link, inline `<style>`/`<script>`, etc. Covers `@solidjs/meta`: wrap your app in `<MetaProvider>` (root-level once), then anywhere in the tree use `<Title>`, `<Meta>`, `<Link>`, `<Style>`, `<Base>` for declarative head tags that update reactively, or `useHead` for low-level imperative access. Server-side setup uses a tags array; client-side mounts under `<MetaProvider>` directly. The deepest rendered tag wins for `<Title>` (so a route's title overrides an app-default). Triggers on: solid-meta, @solidjs/meta, MetaProvider, Title, Meta, Link, Style, Base, useHead, head tags, document title, SEO, OpenGraph, og:, twitter:card, canonical, theme-color, favicon.

Use this skill when upgrading a Solid (SolidJS) project to a newer version of Solid, `@solidjs/router`, or SolidStart, or when diagnosing breakage after such an upgrade. Covers Solid 1.x deprecations and renamed APIs (`className` → `class`, removed lifecycle quirks), Solid Router migration to the current major (renamed primitives like `useRouteData` → `query` + `createAsync`, `cache` → `query`, old `<Outlet>` patterns vs `props.children` + `<FileRoutes>`), and SolidStart v1 migration (the post-vinxi rewrite — file-routing changes, server-function syntax, removed `routeData` exports). Also: how to read CHANGELOGs, what to grep for after an upgrade, and the rule of thumb that if your code references `cache`, `routeData`, or `serverAction`, you're on an old API. Triggers on: migration, upgrade, breaking changes, deprecated, className, cache, routeData, useRouteData, serverAction, createServerData, post-v1, migrating, upgrading Solid Router, upgrading SolidStart.