@vttforge/cli 0.0.0 → 0.5.1

package/templates/system-js/.github/workflows/release.yml

@@ -0,0 +1,92 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Resolve version from tag
+        id: version
+        env:
+          REF: ${{ github.ref_name }}
+        run: |
+          version="${REF#v}"
+          # Git allows surprising characters in tag names. Reject anything
+          # that isn't a strict semver-ish identifier so downstream node -e
+          # / shell interpolations can't be turned into command injection
+          # by a malicious tag push.
+          if ! [[ "$version" =~ ^[0-9A-Za-z._+-]+$ ]]; then
+            echo "Refusing tag with unsafe characters: $version" >&2
+            exit 1
+          fi
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 10
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - run: pnpm install
+
+      - name: Sync manifest version
+        env:
+          VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          node -e "const fs=require('node:fs');const p=JSON.parse(fs.readFileSync('package.json','utf8'));p.version=process.env.VERSION;fs.writeFileSync('package.json',JSON.stringify(p,null,2)+'\n');"
+
+      # We invoke vite directly (not `pnpm build` → `vttforge build`) because
+      # the release workflow needs to:
+      #   1. Run vite build → emit dist/system.json
+      #   2. Patch manifest/download URLs into dist/system.json
+      #   3. Zip dist/ → release artifact (so the zipped manifest carries URLs)
+      # `vttforge build` zips at step 1, which would freeze the un-patched
+      # manifest. Eventually the vite-plugin will support env-driven URL
+      # injection and this dance disappears.
+      - run: pnpm exec vite build
+
+      - name: Inject release URLs into manifest
+        env:
+          VERSION: ${{ steps.version.outputs.version }}
+          REPO: ${{ github.repository }}
+          PKG_ID: '{{ID}}'
+        run: |
+          node -e "const fs=require('node:fs');const path='dist/system.json';const m=JSON.parse(fs.readFileSync(path,'utf8'));const r=process.env.REPO;const v=process.env.VERSION;const id=process.env.PKG_ID;m.manifest=\`https://github.com/\${r}/releases/latest/download/system.json\`;m.download=\`https://github.com/\${r}/releases/download/v\${v}/\${id}-\${v}.zip\`;fs.writeFileSync(path,JSON.stringify(m,null,2)+'\n');"
+
+      - name: Build release zip
+        env:
+          VERSION: ${{ steps.version.outputs.version }}
+          PKG_ID: '{{ID}}'
+        run: |
+          cd dist
+          zip -r "../${PKG_ID}-${VERSION}.zip" .
+
+      - name: Create GitHub Release
+        env:
+          VERSION: ${{ steps.version.outputs.version }}
+          PKG_ID: '{{ID}}'
+        uses: softprops/action-gh-release@v2
+        with:
+          files: |
+            ${{ env.PKG_ID }}-${{ env.VERSION }}.zip
+            dist/system.json
+          generate_release_notes: true
+          body: |
+            ## Foundry installation
+
+            Install via Foundry's setup wizard with this manifest URL:
+
+            ```
+            https://github.com/${{ github.repository }}/releases/latest/download/system.json
+            ```

package/templates/system-js/README.md

@@ -0,0 +1,57 @@
+# {{TITLE}}
+
+{{DESCRIPTION}}
+
+Built on [VTTForge](https://github.com/vttforge/vttforge) — typed data models, declarative sheet boilerplate, migration runner, error catalogue, and a Vite-based build pipeline.
+
+> **Note** — VTTForge is currently in pre-release and not yet published to npm. The dependencies in `package.json` (`@vttforge/core`, `@vttforge/styles`, `@vttforge/vite-plugin`) will resolve once VTTForge ships its first public release. Until then, work from a local checkout: `pnpm link --global` from each VTTForge package, then `pnpm link --global @vttforge/core @vttforge/styles @vttforge/vite-plugin` here.
+
+## Quick start
+
+```bash
+pnpm install
+pnpm dev      # vite build --watch + auto-symlinks dist/ into Foundry's Data
+pnpm build    # one-shot build + emits {{ID}}-<version>.zip for foundryvtt.com
+```
+
+`pnpm dev` (`vttforge dev` under the hood) auto-detects your Foundry user-data
+directory on the first run, prompts you to confirm it, and saves the choice to
+`.vttforge/config.json` for next time. Override with `--data-dir <path>` or set
+`FOUNDRY_DATA_DIR` in your environment.
+
+Run Foundry with `--hotReload` so saved files reload the world without a page
+refresh — `dev` watches `dist/` for changes, and Foundry's built-in dispatcher
+swaps CSS / Handlebars / JSON on the fly.
+
+Then launch Foundry, create a world that uses **{{TITLE}}**, and open a character — the sheet is the `CharacterSheet` shipped in `scripts/sheets/`.
+
+## What's inside
+
+| Path | Purpose |
+|---|---|
+| `system.json` | Manifest (id, compatibility, document types, manifest-side sanitization paths) |
+| `template.json` | Foundry document type declarations (Actor + Item subtypes) |
+| `scripts/main.mjs` | Entry point — one call to `registerSystem` from `@vttforge/core` |
+| `scripts/data/*.mjs` | Typed data models (`BaseTypeDataModel()` from `@vttforge/core`) |
+| `scripts/sheets/*.mjs` | Sheet boilerplate eliminators (`BaseActorSheet()` / `BaseItemSheet()`) |
+| `scripts/migrations.mjs` | `createMigrationRunner()` — versioned data migrations |
+| `templates/` | Handlebars templates for sheets |
+| `styles/main.css` | Stylesheet — imports `@vttforge/styles` as the design system base |
+| `lang/en.json` | Localization strings |
+
+## Releasing to Foundry
+
+Tag-push triggers `.github/workflows/release.yml`, which builds the system, zips `dist/`, and attaches both `{{ID}}-<version>.zip` and `dist/system.json` to a GitHub Release.
+
+```bash
+git tag v0.1.0
+git push --tags
+```
+
+Foundry installs from the `system.json` URL on the Release — point users at the `latest/download/system.json` URL in the release notes so they auto-update on every tag.
+
+For foundryvtt.com submissions, submit the same manifest URL pattern.
+
+## License
+
+{{LICENSE}} © {{YEAR}} {{AUTHOR}}

package/templates/system-js/_gitignore

@@ -0,0 +1,12 @@
+node_modules
+dist
+.turbo
+.vscode
+.DS_Store
+*.log
+
+# vttforge dev — saved Foundry data-dir path
+.vttforge/
+
+# vttforge build — release artifact
+*.zip

package/templates/system-js/lang/en.json

@@ -0,0 +1,55 @@
+{
+  "TYPES.Actor.character": "Character",
+  "TYPES.Item.gear": "Gear",
+
+  "{{LOCALE_PREFIX}}.System.title": "{{TITLE}}",
+  "{{LOCALE_PREFIX}}.System.description": "{{DESCRIPTION}}",
+
+  "{{LOCALE_PREFIX}}.Sheet.Character.title": "Character",
+  "{{LOCALE_PREFIX}}.Sheet.Gear.title": "Gear",
+  "{{LOCALE_PREFIX}}.Sheet.NamePlaceholder": "Name…",
+  "{{LOCALE_PREFIX}}.Sheet.Level": "LV",
+  "{{LOCALE_PREFIX}}.Sheet.AbilityScores": "Ability scores",
+  "{{LOCALE_PREFIX}}.Sheet.Inventory": "Inventory",
+  "{{LOCALE_PREFIX}}.Sheet.Biography": "Biography",
+  "{{LOCALE_PREFIX}}.Sheet.NewGear": "New gear",
+  "{{LOCALE_PREFIX}}.Sheet.NewGearName": "New Gear",
+  "{{LOCALE_PREFIX}}.Sheet.NoGear": "No gear yet — drag items here or click New gear.",
+  "{{LOCALE_PREFIX}}.Sheet.Delete": "Delete",
+
+  "{{LOCALE_PREFIX}}.Sheet.Quick.HP": "HP",
+  "{{LOCALE_PREFIX}}.Sheet.Quick.AC": "AC",
+  "{{LOCALE_PREFIX}}.Sheet.Quick.SPD": "SPD",
+  "{{LOCALE_PREFIX}}.Sheet.Quick.INIT": "INIT",
+
+  "{{LOCALE_PREFIX}}.Sheet.Tabs.abilities": "Abilities",
+  "{{LOCALE_PREFIX}}.Sheet.Tabs.inventory": "Inventory",
+  "{{LOCALE_PREFIX}}.Sheet.Tabs.spells": "Spells",
+  "{{LOCALE_PREFIX}}.Sheet.Tabs.biography": "Biography",
+  "{{LOCALE_PREFIX}}.Sheet.Tabs.details": "Details",
+  "{{LOCALE_PREFIX}}.Sheet.Tabs.description": "Description",
+  "{{LOCALE_PREFIX}}.Sheet.Spells": "Spells",
+  "{{LOCALE_PREFIX}}.Sheet.SpellsEmpty": "Spells slot reserved for a follow-up release.",
+
+  "{{LOCALE_PREFIX}}.Sheet.Roll.label": "Roll",
+  "{{LOCALE_PREFIX}}.Sheet.Roll.flavor": "{ability} check",
+  "{{LOCALE_PREFIX}}.Sheet.Drop.label": "Drop item to add",
+  "{{LOCALE_PREFIX}}.Sheet.Drop.rejected": "Cannot drop {type} items here — only gear is accepted.",
+
+  "{{LOCALE_PREFIX}}.Ability.str": "Strength",
+  "{{LOCALE_PREFIX}}.Ability.dex": "Dexterity",
+  "{{LOCALE_PREFIX}}.Ability.con": "Constitution",
+  "{{LOCALE_PREFIX}}.Ability.int": "Intelligence",
+  "{{LOCALE_PREFIX}}.Ability.wis": "Wisdom",
+  "{{LOCALE_PREFIX}}.Ability.cha": "Charisma",
+
+  "{{LOCALE_PREFIX}}.Gear.Quantity": "Quantity",
+  "{{LOCALE_PREFIX}}.Gear.Weight": "Weight (lb)",
+  "{{LOCALE_PREFIX}}.Gear.Kind": "Kind",
+  "{{LOCALE_PREFIX}}.Gear.Kind.equipped": "equipped",
+  "{{LOCALE_PREFIX}}.Gear.Kind.valued": "valued",
+  "{{LOCALE_PREFIX}}.Gear.Kind.stowed": "stowed",
+
+  "{{LOCALE_PREFIX}}.Settings.showTutorial.name": "Show tutorial",
+  "{{LOCALE_PREFIX}}.Settings.showTutorial.hint": "Display the welcome banner on world load."
+}

package/templates/system-js/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "{{ID}}",
+  "version": "0.1.0",
+  "private": true,
+  "description": "{{DESCRIPTION}}",
+  "type": "module",
+  "license": "{{LICENSE}}",
+  "author": "{{AUTHOR}}",
+  "scripts": {
+    "build": "vttforge build",
+    "dev": "vttforge dev"
+  },
+  "dependencies": {
+    "@vttforge/core": "^0.10.0",
+    "@vttforge/styles": "^0.3.0"
+  },
+  "devDependencies": {
+    "@vttforge/cli": "^0.5.0",
+    "@vttforge/vite-plugin": "^0.4.0",
+    "vite": "^8.2.2"
+  },
+  "engines": {
+    "node": ">=26"
+  }
+}

package/templates/system-js/scripts/data/character-data.mjs

@@ -0,0 +1,79 @@
+/**
+ * CharacterData — typed schema for the `character` Actor type.
+ *
+ * Quick stats are HP / AC / SPD / INIT, abilities are the six classic
+ * scores (str/dex/con/int/wis/cha). Derived state (modifiers, max HP,
+ * armor class, initiative) is computed in-memory in `prepareDerivedData`.
+ *
+ * `prepareBaseData` initialises fields that Active Effects need to mutate
+ * (base max HP before any AE bonus); `prepareDerivedData` then computes
+ * the AE-aware values (modifiers, percentages, totals). Never write to the
+ * database in either hook — they're purely in-memory derivations.
+ */
+import { BaseTypeDataModel, fields } from '@vttforge/core';
+
+export class CharacterData extends BaseTypeDataModel() {
+  static defineSchema() {
+    const f = fields();
+    // The six ability scores are written once, as a factory rather than a
+    // shared options object: a field keeps the options it was handed, and
+    // some field classes write back into them.
+    const score = () =>
+      new f.NumberField({
+        required: true,
+        nullable: false,
+        integer: true,
+        min: 1,
+        max: 30,
+        initial: 10,
+      });
+    return {
+      level: new f.NumberField({
+        required: true,
+        nullable: false,
+        integer: true,
+        min: 1,
+        max: 20,
+        initial: 1,
+      }),
+      speed: new f.NumberField({
+        required: true,
+        nullable: false,
+        integer: true,
+        min: 0,
+        initial: 30,
+      }),
+      abilities: new f.SchemaField({
+        str: score(),
+        dex: score(),
+        con: score(),
+        int: score(),
+        wis: score(),
+        cha: score(),
+      }),
+      health: new f.SchemaField({
+        value: new f.NumberField({ required: true, nullable: false, integer: true, min: 0, initial: 10 }),
+        max: new f.NumberField({ required: true, nullable: false, integer: true, min: 0, initial: 10 }),
+      }),
+      power: new f.SchemaField({
+        value: new f.NumberField({ required: true, nullable: false, integer: true, min: 0, initial: 5 }),
+        max: new f.NumberField({ required: true, nullable: false, integer: true, min: 0, initial: 5 }),
+      }),
+      biography: new f.HTMLField(),
+    };
+  }
+
+  prepareDerivedData() {
+    for (const [key, value] of Object.entries(this.abilities)) {
+      const score = typeof value === 'number' ? value : (value?.value ?? 10);
+      const mod = Math.floor((score - 10) / 2);
+      this.abilities[key] = { value: score, mod };
+    }
+
+    const conMod = this.abilities.con.mod;
+    this.health.max = 10 + this.level + conMod;
+
+    this.armorClass = 10 + this.abilities.dex.mod;
+    this.initiative = this.abilities.dex.mod;
+  }
+}

package/templates/system-js/scripts/data/gear-data.mjs

@@ -0,0 +1,37 @@
+/**
+ * GearData — typed schema for the `gear` Item type.
+ *
+ * `kind` is an enum that drives the inventory pill on the character sheet:
+ * `equipped` and `valued` render with the accent pill, `stowed` renders
+ * muted.
+ */
+import { BaseTypeDataModel, fields } from '@vttforge/core';
+
+const GEAR_KINDS = /** @type {const} */ (['equipped', 'valued', 'stowed']);
+
+export class GearData extends BaseTypeDataModel() {
+  static defineSchema() {
+    const f = fields();
+    return {
+      quantity: new f.NumberField({
+        required: true,
+        nullable: false,
+        integer: true,
+        min: 0,
+        initial: 1,
+      }),
+      weight: new f.NumberField({
+        required: true,
+        nullable: false,
+        min: 0,
+        initial: 0,
+      }),
+      kind: new f.StringField({
+        required: true,
+        choices: GEAR_KINDS,
+        initial: 'stowed',
+      }),
+      description: new f.HTMLField(),
+    };
+  }
+}

package/templates/system-js/scripts/main.mjs

@@ -0,0 +1,79 @@
+/**
+ * {{TITLE}} — entry point.
+ *
+ * `registerSystem` from `@vttforge/core` replaces the ~60-line
+ * `Hooks.once("init", ...)` block most systems copy-paste from each other:
+ * data model registration, document class swap, initiative formula, sheet
+ * registration, settings, and the `Hooks.once("ready", ...)` migration
+ * gate are all wired by one call.
+ */
+import { registerSystem, SystemConfig, VttfError } from '@vttforge/core';
+import { CharacterData } from './data/character-data.mjs';
+import { GearData } from './data/gear-data.mjs';
+import { migrations } from './migrations.mjs';
+import { CharacterSheet } from './sheets/character-sheet.mjs';
+import { GearSheet } from './sheets/gear-sheet.mjs';
+
+const SYSTEM_ID = '{{ID}}';
+
+const settings = new SystemConfig(SYSTEM_ID);
+
+try {
+  registerSystem({
+    id: SYSTEM_ID,
+    actorDataModels: { character: CharacterData },
+    itemDataModels: { gear: GearData },
+    combat: {
+      initiative: { formula: '1d20 + @abilities.dex.mod', decimals: 2 },
+    },
+    onAfterInit: () => {
+      settings.register('showTutorial', {
+        name: '{{LOCALE_PREFIX}}.Settings.showTutorial.name',
+        hint: '{{LOCALE_PREFIX}}.Settings.showTutorial.hint',
+        scope: 'client',
+        config: true,
+        type: Boolean,
+        default: true,
+      });
+
+      // Register the schemaVersion setting so migrations.run() has somewhere
+      // to read and write the version flag.
+      migrations.register();
+
+      const { Actors, Items } = foundry.documents.collections;
+      Actors.unregisterSheet('core', foundry.applications.sheets.ActorSheetV2);
+      Actors.registerSheet(SYSTEM_ID, CharacterSheet, {
+        types: ['character'],
+        makeDefault: true,
+        label: '{{LOCALE_PREFIX}}.Sheet.Character.title',
+      });
+      Items.unregisterSheet('core', foundry.applications.sheets.ItemSheetV2);
+      Items.registerSheet(SYSTEM_ID, GearSheet, {
+        types: ['gear'],
+        makeDefault: true,
+        label: '{{LOCALE_PREFIX}}.Sheet.Gear.title',
+      });
+    },
+    onReady: async () => {
+      if (!game.user?.isGM) return;
+      try {
+        const ran = await migrations.run();
+        if (ran.length > 0) {
+          console.info(`[${SYSTEM_ID}] applied migrations:`, ran.join(', '));
+        }
+      } catch (err) {
+        if (err instanceof VttfError) {
+          ui.notifications?.error(`[${err.code}] ${err.message} — see ${err.docsUrl}`, {
+            permanent: true,
+          });
+        }
+        throw err;
+      }
+    },
+  });
+} catch (err) {
+  if (err instanceof VttfError) {
+    console.error(`[${err.code}] ${err.message} — see ${err.docsUrl}`);
+  }
+  throw err;
+}

package/templates/system-js/scripts/migrations.mjs

@@ -0,0 +1,43 @@
+/**
+ * Migration registry for {{TITLE}}.
+ *
+ * Each entry is idempotent — safe to re-run if a prior pass failed
+ * mid-sequence. `createMigrationRunner` reads the version flag declared in
+ * `system.json` (`flags.{{ID}}.needsMigrationVersion`), runs every
+ * migration whose version is newer than what's stored in the world's
+ * `schemaVersion` setting, and persists the new high-water mark on success.
+ */
+import { createMigrationRunner } from '@vttforge/core';
+
+const SYSTEM_ID = '{{ID}}';
+
+/**
+ * v0.1.0 — first real schema. Add real migration logic here as soon as the
+ * first breaking schema change ships. Until then, this is a no-op example
+ * that proves the runner end-to-end.
+ */
+async function migrateToV0_1_0() {
+  // Iterate world documents and rewrite legacy fields here. Example:
+  //
+  //   const actors = game.actors?.filter((a) => a.type === 'character') ?? [];
+  //   for (const actor of actors) {
+  //     const legacy = actor.system?.bio;
+  //     if (typeof legacy !== 'string') continue;
+  //     await actor.update({
+  //       'system.biography': legacy,
+  //       '-=system.bio': null,
+  //     });
+  //   }
+}
+
+export const migrations = createMigrationRunner({
+  systemId: SYSTEM_ID,
+  compatibleVersion: '0.0.0',
+  migrations: [
+    {
+      version: '0.1.0',
+      description: 'initial schema — placeholder for first breaking change',
+      fn: migrateToV0_1_0,
+    },
+  ],
+});

package/templates/system-js/scripts/sheets/character-sheet.mjs

@@ -0,0 +1,164 @@
+/**
+ * CharacterSheet — tabbed character sheet built on `BaseActorSheet()` from
+ * `@vttforge/core`. Demonstrates the full boilerplate-elimination surface:
+ *
+ * - `static TABS` — `context.tabs.<group>` auto-populated by BaseActorSheet
+ *   (no manual `_prepareTabs` call).
+ * - `static DRAG_DROP` — wires `foundry.applications.ux.DragDrop` on first
+ *   render with `isEditable`-gated permissions.
+ * - Typed `onDropItem(item, event)` — pre-resolves UUIDs, rejects
+ *   non-`gear` items with a notification, lets `gear` flow through to
+ *   Foundry's default `_onDropItem` by returning `undefined`.
+ */
+import { BaseActorSheet } from '@vttforge/core';
+
+const SYSTEM_ID = '{{ID}}';
+
+export class CharacterSheet extends BaseActorSheet() {
+  static DEFAULT_OPTIONS = foundry.utils.mergeObject(
+    super.DEFAULT_OPTIONS,
+    {
+      id: '{{ID}}-character',
+      classes: ['{{ID}}', 'sheet', 'actor', 'character'],
+      window: {
+        title: '{{LOCALE_PREFIX}}.Sheet.Character.title',
+        icon: 'fa-solid fa-user',
+      },
+      position: { width: 640, height: 700 },
+      actions: {
+        rollAbility: CharacterSheet._onRollAbility,
+        createGear: CharacterSheet._onCreateGear,
+        deleteItem: CharacterSheet._onDeleteItem,
+      },
+    },
+    { inplace: false },
+  );
+
+  static PARTS = {
+    sheet: {
+      template: `systems/${SYSTEM_ID}/templates/actor/character-sheet.hbs`,
+    },
+  };
+
+  static TABS = {
+    primary: {
+      tabs: [
+        {
+          id: 'abilities',
+          group: 'primary',
+          label: '{{LOCALE_PREFIX}}.Sheet.Tabs.abilities',
+          icon: 'fa-solid fa-dumbbell',
+        },
+        {
+          id: 'inventory',
+          group: 'primary',
+          label: '{{LOCALE_PREFIX}}.Sheet.Tabs.inventory',
+          icon: 'fa-solid fa-sack',
+        },
+        {
+          id: 'spells',
+          group: 'primary',
+          label: '{{LOCALE_PREFIX}}.Sheet.Tabs.spells',
+          icon: 'fa-solid fa-wand-magic-sparkles',
+        },
+        {
+          id: 'biography',
+          group: 'primary',
+          label: '{{LOCALE_PREFIX}}.Sheet.Tabs.biography',
+          icon: 'fa-solid fa-feather',
+        },
+      ],
+      initial: 'abilities',
+    },
+  };
+
+  static DRAG_DROP = [
+    {
+      dragSelector: '.sh-item[draggable=true]',
+      dropSelector: '.sh-body',
+    },
+  ];
+
+  /** @override */
+  async _prepareContext(options) {
+    const context = await super._prepareContext(options);
+    const actor = this.document;
+    const system = actor.system;
+    const abilityLabels = {
+      str: '{{LOCALE_PREFIX}}.Ability.str',
+      dex: '{{LOCALE_PREFIX}}.Ability.dex',
+      con: '{{LOCALE_PREFIX}}.Ability.con',
+      int: '{{LOCALE_PREFIX}}.Ability.int',
+      wis: '{{LOCALE_PREFIX}}.Ability.wis',
+      cha: '{{LOCALE_PREFIX}}.Ability.cha',
+    };
+    context.actor = actor;
+    context.system = system;
+    context.isEditable = this.isEditable;
+    context.abilities = Object.entries(system.abilities ?? {}).map(([key, data]) => ({
+      key,
+      label: game.i18n.localize(abilityLabels[key] ?? key),
+      value: data?.value ?? data,
+      mod: data?.mod ?? 0,
+    }));
+    context.gear = actor.items
+      .filter((item) => item.type === 'gear')
+      .map((item) => ({
+        id: item.id,
+        name: item.name,
+        img: item.img,
+        kind: item.system?.kind ?? 'stowed',
+        quantity: item.system?.quantity ?? 1,
+        weight: item.system?.weight ?? 0,
+        description: item.system?.description ?? '',
+      }));
+    context.enrichedBiography = await foundry.applications.ux.TextEditor.implementation.enrichHTML(
+      system.biography ?? '',
+      { relativeTo: actor, secrets: actor.isOwner },
+    );
+    return context;
+  }
+
+  /** Reject non-gear drops with a notification; let gear fall through. */
+  async onDropItem(item, _event) {
+    if (item?.type !== 'gear') {
+      ui.notifications?.warn(
+        game.i18n.format('{{LOCALE_PREFIX}}.Sheet.Drop.rejected', { type: item?.type ?? 'unknown' }),
+      );
+      return false;
+    }
+    return undefined;
+  }
+
+  static async _onRollAbility(_event, target) {
+    const key = target?.dataset?.ability;
+    if (!key) return;
+    const actor = this.document;
+    const mod = actor.system.abilities?.[key]?.mod ?? 0;
+    const roll = new Roll(`1d20 + ${mod}`, actor.getRollData());
+    await roll.evaluate();
+    await roll.toMessage({
+      speaker: ChatMessage.getSpeaker({ actor }),
+      flavor: game.i18n.format('{{LOCALE_PREFIX}}.Sheet.Roll.flavor', {
+        ability: game.i18n.localize(`{{LOCALE_PREFIX}}.Ability.${key}`),
+      }),
+    });
+  }
+
+  static async _onCreateGear(_event, _target) {
+    const cls = CONFIG.Item.documentClass;
+    const parent = this.document;
+    await cls.create(
+      { name: game.i18n.localize('{{LOCALE_PREFIX}}.Sheet.NewGearName'), type: 'gear' },
+      { parent, renderSheet: true },
+    );
+  }
+
+  static async _onDeleteItem(_event, target) {
+    const row = target?.closest('[data-item-id]');
+    const id = row?.dataset?.itemId;
+    if (!id) return;
+    const item = this.document.items.get(id);
+    await item?.delete();
+  }
+}