Retrieve D&D 5e character information optimized for minimal token usage. Returns: full stats (abilities, skills, saves, AC, HP), action names, active effects/conditions (name only), and ALL items with minimal metadata (name, type, equipped status, attunement) without descriptions. Perfect for checking equipment or identifying what to investigate further. Use get-actor-entity to fetch full details for specific items, spells, or effects.

List all available characters with basic information

Retrieve full details for a specific entity from a character. Works for items (feats, equipment, spells), actions (strikes, special abilities), or effects/conditions. Returns complete description and all system data. Use this after get-actor when you need detailed information about a specific entity.

Search within a character's items, spells, actions, and effects. More token-efficient than get-actor when you need specific items. Supports text search (name/description) and type filtering. Returns matching items with full details including targeting info for spells. Use this to find specific spells, equipment, feats, or abilities without loading the entire character.

Create world-level Item document(s) in the Items sidebar — reusable library items (weapons, equipment, consumables, feats, spells). For dnd5e prefer the 2024 data model; pass system-specific data via the "system" field. GM-only. To put items on an actor instead, copy from a compendium with import-item, author one with add-item, or attach raw item data with add-feature (mode "items").

List world-level Item documents, optionally filtered by type, name substring, or folder.

Retrieve a single world-level Item document with its full system data, embedded effects, flags, and flattened description. Resolves by id (most reliable), exact name, or case-insensitive name. Use list-items first to find ids. For an UNIDENTIFIED dnd5e item (system.identified=false) name is the mystery mask; the real source name is returned as trueName.

Update existing world-level Item(s) by id — change name, img, system data, or folder. GM-only. Renaming an UNIDENTIFIED dnd5e item works on the true source name; the echo shows the mystery-mask name plus trueName so the rename is visible.

Permanently delete one or more world-level Item documents (Items sidebar) by exact id or exact name. STRICT resolution — no fuzzy/substring matching, so it never deletes the wrong item. GM-only. To remove an item embedded on an actor instead, use remove-from-actor.

Delete items already on an actor, identified by itemIds and/or itemNames (optionally constrained by type). GM-only. Use get-actor to find item ids.

Broad NAME search across the premium book compendium packs (any document type). The SRD (dnd5e.*) packs are NOT searched and never appear in results — the authoring library is the premium books only (design.md §2.3). Matches entity NAMES only (all whitespace-separated terms must appear); descriptions and traits are NOT searchable. Premium-first ranked, exact-name first. For faceted discovery by real system data (CR/type/size, spell level/school, item rarity/type), use the type-specific tools instead: search-compendium-creatures, search-compendium-spells, search-compendium-items. Use this for a quick name lookup, then inspect with get-compendium-entry.

Retrieve a specific compendium entry (monster, item, spell, etc.) by pack id + entry id. Returns the full stat block — items, spells, abilities, effects, system data — needed for actor/item creation. Set compact=true for a condensed stat block when full detail is not needed. An SRD (dnd5e.*) pack id is refused — author only from the premium books (design.md §2.3).

D&D 5e CREATURE DISCOVERY: find creatures matching faceted criteria (Challenge Rating, type, size, spellcasting, legendary actions) across the premium book Actor packs only — the SRD (dnd5e.*) packs are excluded and never appear in results (design.md §2.3). Backed by the system Compendium Browser, so CR/type/size check real system data (not name heuristics); hasSpells/hasLegendaryActions are approximate index flags. Returns minimal hits ({id,name,type,uuid,pack,packLabel,img,facets}) premium-first ranked — identify candidates by name, then pull full stat blocks with get-compendium-entry. High result limits for complete encounter-building surveys.

D&D 5e SPELL DISCOVERY: find spells matching faceted criteria (level, school, damage type, name) across the premium book packs only — the SRD (dnd5e.*) packs are excluded and never appear in results (design.md §2.3). Backed by the system Compendium Browser, so filters check real spell data (not name heuristics). Returns minimal hits ({id,name,type,uuid,pack,packLabel,img,facets}) premium-first ranked — identify candidates here, then pull full detail with get-compendium-entry. damageType is a two-stage refine (loads candidate spells to inspect their activities).

D&D 5e ITEM/GEAR DISCOVERY: find equipment, weapons, armor, consumables, and treasure matching faceted criteria (rarity, subtype, properties, magical, name) across the premium book packs only — the SRD (dnd5e.*) packs are excluded and never appear in results (design.md §2.3). Backed by the system Compendium Browser, so filters check real item data (not name heuristics). Returns minimal hits ({id,name,type,uuid,pack,packLabel,img,facets}) premium-first ranked — identify candidates here, then pull full detail with get-compendium-entry. Use documentType to narrow the item family (gear=all, or weapon/armor/consumable).

List the available compendium packs. SRD (dnd5e.*) packs are excluded — only the premium book packs (and any other non-SRD packs) are listed (design.md §2.3).

Get information about the currently active scene, including tokens and layout

Get basic information about the Foundry world and system

Copy one or more actors from a premium-book compendium pack — the DEFAULT, preferred path for official content (e.g. pull the Owlbear from the Monster Manual). Find the entry with search-compendium / get-compendium-entry, then pass its packId + itemId plus names[] for the new actors. PREFAB-AS-BASE (the §6 step-2 bridge): to make a CUSTOM creature, copy the closest Monster Manual match and pass modifications (update-actor-shaped stat edits — cr/hp/ac/abilities/skills/defenses/biography/currency) to layer onto the world copy in the SAME call; the edits land on the copy only, never the source entry. For a fully hand-authored NPC with no compendium base, use author-npc (last resort).

Author a custom NPC (type:npc) from a hand-written stat block — the LAST-RESORT path in the §6 ladder, used ONLY when nothing in the premium MM/PHB/DMG books is a workable base. Prefer create-actor-from-compendium (copy a real Monster Manual creature, optionally with prefab-as-base modifications); if the books are missing what you need, tell the user and ask before authoring rather than inventing content. Prefer the 2024 ruleset (sourceRules:'2024'). Required: name, creatureType (humanoid/undead/beast/dragon/fiend/…), size (tiny…gargantuan), cr (number or fraction string like '1/4'), abilities {str,dex,con,int,wis,cha}, hpAverage, hpFormula (e.g. '5d8+10'), acMode ('default'|'flat'; acValue required if 'flat'). Optional: alignment, savingThrows[], skills[{skill,proficiency}], walk/fly/swim/climb/burrowSpeed, darkvision/blindsight/tremorsense/truesight, damage immunities/resistances/vulnerabilities[], conditionImmunities[], languages[], biography, sourceBook/sourcePage/sourceRules, disposition ('hostile' default | 'friendly' for allies/townsfolk | 'neutral' | 'secret'). Add features, attacks, and spells afterward with add-feature; copy gear from a compendium with import-item.

Build a player character (type:character) headlessly from premium class + species + background by NAME, running real dnd5e advancement so @scale.* (rage damage, sneak attack, breath weapon, …) resolves natively — unlike an NPC. Compendium-first, premium books only, never the SRD (design.md §2.3); a missing class/species/background is an error, not invented. The SKILL owns the math: pass FINAL ability scores (point-buy/array/ASI already applied) and the player CHOICES (skills, fighting style, ancestry…) in choices (level → advancement-id → {chosen|selected|uuid}). Call with no/partial choices first to get a needsChoices[] dry-run (legal options per choice — incl. the available subclasses at level 3 — NOTHING is created); fill the map and re-call. Levels 1-20: HP/features/subclass/spell-slots scale with level (subclass at L3 via a choices uuid; HP per level hpMode avg|max). Multiclass in ONE call via multiclass:[{className,levels}] (className/level is the primary; each multiclass class gets the 2024 proficiency subset; total ≤ 20). Caster spell slots auto-derive from the class; pass spells.cantrips/spells.prepared (names) to add chosen spells. ASI ability-increases ride in the FINAL scores (not applied separately); a feat taken at an ASI tier is added by the skill via add-feature/import-item, like equipment — this tool adds no gear or ASI-feats. If a required advancement (a forced grant / supplied pick / subclass embed) FAILS to apply, the PC is NOT persisted (no junk actor) and success:false is returned with errors[]. Returns {success, actor, applied[], needsChoices[], unresolvedScale[], errors[], warnings[]}.

Read-only: report the player CHOICE points a premium class exposes up to a level — each advancement's id, type (Trait/ItemChoice/Subclass), how many to pick, and the legal options — so the skill can ask the DM and fill create-pc's choices map without inventing anything. Resolve by className OR classUuid (exactly one); premium books only, never the SRD. Touches no actor.

Add ONE level to an existing PC (type:character) and apply that level's advancement IN PLACE. Same className as a class the PC already has → a single-class level-up; a class it does NOT have → a MULTICLASS add (the PC gets the 2024 multiclass proficiency SUBSET, not the full first-level kit). HP/features/subclass(@ the class's level 3)/spell-slots scale; @scale stays native. Like create-pc: call with no/partial choices to get a needsChoices[] dry-run (e.g. the subclass options at level 3 — the actor is NOT touched); fill choices (level → advancement-id → {chosen|selected|uuid}) and re-call. ASI ability bumps are NOT applied here — raise the final scores with update-actor; a feat taken at an ASI tier is added with add-feature. If a required advancement FAILS to apply, the PC is rolled back to its prior level and success:false is returned with errors[]. Required: actorIdentifier, className. Returns {success, actor (incl. classLevel + classes[]), applied[], needsChoices[], unresolvedScale[], errors[], warnings[]}.

Create a player character by COPYING a premium-book PREGEN (a complete type:character template — e.g. the PHB class pregens Barbarian…Wizard in dnd-players-handbook.actors, each a ready level-1 build with gear/feats/art) and layering your changes, INSTEAD of building via advancement. The PC family's prefab-as-base path — the §6/§7 analog of create-actor-from-compendium for NPCs, but PC-correct (files under the PC folder, never the NPC one). Resolve the source by prefab NAME (e.g. "Fighter") OR explicit packId+actorId; premium books only, never the SRD (design.md §2.3). Override the pregen's ability array via abilities (final scores) and/or any update-actor-shaped modifications — applied to the COPY only, the source is never touched. @scale resolves natively (it is a real character, no advancement run). Assign the player as owner afterward with set-actor-ownership. Returns {success, from, actor, modificationsApplied, unresolvedScale, warnings}.

Permanently delete one or more world actors (NPCs/characters) by exact name or ID. IRREVERSIBLE — Foundry has no undo for document deletion; the actor is removed from the world directory. GM-only. Resolution is STRICT (exact id or exact name — no fuzzy matching), so look up the precise name/ID with list-actors first. If the deletion empties a folder the bridge itself created (e.g. "Foundry MCP Creatures"), that folder is auto-removed unless removeEmptyFolder is false.

Permanently delete a folder by exact name or ID. GM-only, IRREVERSIBLE. By default refuses to delete a folder that still contains documents or subfolders (safe for cleaning up empty leftover folders). Pass deleteContents:true to delete the folder AND everything inside it. Defaults to Actor folders; set type for other document folders.

[D&D 5e only] Edit an EXISTING actor's own stat-block fields. Supply only the groups you want to change: • identity + prototype token — name, tokenName (prototype nameplate ≠ actor name), img, disposition (friend/foe), tokenAutoRotate (face movement / lockRotation), tokenRing (dynamic ring), tokenScale (art size), tokenRotation (facing) — the PROTOTYPE-token editor. (elevation / hidden / x / y are placement-only: edit those on a dropped token with update-token) • details — size, cr*, creatureType*, creatureSubtype*, swarmSize*, alignment, biography, source • abilities — abilities.{str..cha}, savingThrows (replace), skills (merge; proficiency none/proficient/expert) • vitals — hp, ac, initiative • movement, senses • defenses — damageImmunities / damageResistances / damageVulnerabilities / conditionImmunities / languages (each {mode: replace|add|remove, values, custom?}), telepathy • resources* — legendaryActions, legendaryResistances, lair • 2024* — habitat, treasure • currency — coins {mode: set|add, pp, gp, ep, sp, cp} (carried money)

Fields marked * are NPC-only (skipped with a warning on player characters). This authors the stat block; it does NOT edit embedded items (use update-actor-item / add-feature / manage-activity) or run combat. Use list-actors or get-actor to find the actorIdentifier.

[D&D 5e] Edit an item embedded on an actor (weapon / feature / spell / equipment). Apply a dot-path patch (values applied as-is; arrays/Sets replace whole) and/or deletePaths (remove keys, e.g. an activity by id), and/or change name/img. This is the low-level item editor — to add/edit/remove activities (attacks, saves, heals, etc.) prefer manage-activity, which knows the shapes. Use get-actor or get-actor-entity to find the item and the exact paths/ids to change.

[D&D 5e only] Add / edit / remove / list Activities on an item — the rollable things (attack, damage, save, heal, check, utility, cast). Target an item on an actor (set actorIdentifier) or a world item (omit it). This authors actions like a Multiattack (action="add", type="utility", name="Multiattack"), a heal, an ability-check, a saving-throw activity, OR a spell-casting item (action="add", type="cast", spellUuid=…, charges=…, saveDC/attackBonus=… to pin a fixed challenge) — the cast LINKS a real compendium spell so its measured template + save/attack fire for free. Use action="list" (or get-actor-entity) to find activityIds, then edit/remove by id; edit takes a patch of dot-paths relative to the activity. Authoring only — it does not run combat.

[D&D 5e] Create / edit / delete / list ActiveEffects on an actor or an item. Effects carry changes ({key, value, type}) that modify the target — e.g. +1 AC ({key:"system.attributes.ac.bonus", value:"1", type:"add"}) or resist fire. Target the actor (actorIdentifier), an embedded item (actorIdentifier + itemIdentifier), or a world item (itemIdentifier alone). Use action="list" to find effectIds. Item effects transfer to the owning actor by default. Authoring only — it sets effect data, it does not run combat.

[D&D 5e only] Apply or remove one or more conditions on an actor (blinded, frightened, grappled, poisoned, prone, restrained, stunned, unconscious, exhaustion, ...). Set active=false to remove. Exhaustion is leveled — pass exhaustionLevel (1-6; 0 removes). This authors condition state on a creature; it is NOT a combat-automation loop (no duration countdown / save-ends handling). Use list-actors or get-actor to find the actorIdentifier.

[D&D 5e only] Create a structured physical item (loot/gear) on an actor or in the world Items sidebar. Pick itemType, then supply only the fields you need — sensible defaults fill the rest:

• weapon — to-hit weapon. damage (base die), weaponClass, attackType, reach/range, magicalBonus, properties. Builds a rollable attack activity by default (withAttack). • armor / shield — armorValue, dex, strength; magicalBonus = +N AC. Pass wireAc (BODY ARMOR only) to make the actor derive AC from the worn armor; a shield needs no wireAc (its +2 applies under any AC calc). • wondrous — rings/cloaks/etc. (equipmentType); use magical:true + attunement (a wondrous item has no numeric +N field — model a bonus with manage-effect). • consumable — potion/scroll/ammo/wand. consumableType, uses {max, recovery, autoDestroy}. Ammo can carry damage + ammoReplace + magicalBonus. • tool — toolType, ability, proficient, toolBonus. • loot — gems/art/trade goods (lootType, price). NOT equippable/attunable. • container — bag/chest with capacity and an inner currency pile. Place items inside any container with the container param (id or name).

Cross-cutting: price, weight, quantity, rarity, identified, equipped, attunement (""/required/optional) + attuned, magicalBonus (the +N), properties (incl. "mgc"). Setting magicalBonus/magical adds the mgc flag; the numeric +N is stored for weapons, body armor, and magic ammo (wondrous/potion have no +N field). Unlike add-feature, add-item does NOT reject a duplicate name — intentional, so you can author stacks/copies; de-dupe yourself if you need uniqueness.

Target: actorIdentifier embeds on that actor; omit it to create a reusable world Item (optionally in folder). This authors documents — it does NOT roll, equip-in-combat, or spend charges. For features/attacks-as-abilities use add-feature; for free-form system data use create-item / add-feature. To COPY a real item from a compendium (keeps art + stats), prefer import-item.

[D&D 5e only] COPY an existing item from a compendium pack onto an actor (or into the world Items sidebar), keeping its artwork, full system data, and activities. PREFER THIS over add-item for any real piece of gear — a plain greatsword, a Potion of Healing, a +1 shield, a magic weapon: copying brings the correct PHB/DMG 2024 stats AND the graphic, where authoring from scratch does not.

WORKFLOW: 1) find the item with search-compendium (prefer the 2024 packs: "dnd-players-handbook.equipment", "dnd-dungeon-masters-guide.equipment" — premium books ONLY, never the dnd5e.* SRD); 2) import-item with its packId + itemId; 3) for a CUSTOM item, copy the closest base then refine it with update-actor-item / manage-activity / manage-effect and rename via name.

Optional on-copy tweaks: name (rename), quantity, equipped, identified, container (nest in a bag/chest), folder (world target only). Target an actor with actorIdentifier, or omit it to build a reusable world Item. Use add-item only for genuine homebrew with no compendium base.

[D&D 5e only] Finishing check for authored content — scan documents for the four strict authoring-quality rules and report violations to fix (read-only; never mutates): • rule 8 — placeholder icons (icons/svg/...) on an actor, item, or authored feature. • rule 7 — GM-fudge / pretend-reskin language in a description or biography ("treat its X as Y", "reflavor", "deals necrotic in place of bludgeoning", "pretend", "is really "). • rule 9 — a magic item on an NPC with no matching world-Item loot twin. • rule 12 — a GM-note / spoiler leaked into a PLAYER-VISIBLE item description ("GM:" asides, "the DM", "fill in the …", "ready-made hook", "to suit your table"). Item descriptions only — an NPC biography is GM-facing, so it is not scanned for this.

RUN THIS before declaring a build done. Target what you built: actorIdentifiers (NPCs, with their gear/features), itemFolders (your loot folder), and/or worldItemIds. With NO target it runs a full sweep of every NPC + every world Item. Fix each finding (set a real icon via update-actor-item/update-item/set-actor-art; replace fudge with real mechanics; mint the missing loot copy; rewrite the item description to innocuous in-world flavor and move the GM note to a GM-only journal) then re-run until clean.

Parse a D&D Beyond character into a normalized, name-bearing plan for the ddb-import skill. Fetches a PUBLIC character by characterId/url (v5 endpoint) OR accepts pasted json (the common case — a PRIVATE character must be set Public or its JSON pasted; this tool NEVER handles a D&D Beyond account cookie). Pure + deterministic: it computes final ability scores (deduping DDB's per-class modifier duplication, resolving choose-an-ability-score, honoring overrides), the classes/multiclass + subclasses, species, background, derived proficiencies/expertise/saves/languages/tools, resolved option picks (fighting style, favored enemy…), spells (cantrips + prepared/known by name), inventory, feats, currency, HP, art, and an unresolved[] list of every homebrew / 2014-legacy / custom entry to STOP-and-ASK about. It emits RAW DDB names, does ZERO compendium lookup, and never invents content (design.md §2.3). The skill then canonicalizes names to premium-2024 entries and drives create-pc. Returns {success, plan, message}.

Add a feature/spell/ability to an existing actor (NPC or PC). Set mode: • 'compendium-features' — import named class/monster features from an official compendium (PREFERRED for official content, e.g. Pack Tactics, Multiattack, Spellcasting). Params under compendiumFeatures. • 'feature' — author a feature/attack/spellcasting setup/spells from scratch (use only when not available in a compendium). Params under feature (select feature.featureType). • 'items' — attach world items by raw data. For real GEAR prefer import-item (copy from a compendium, keeps art+stats) or add-item (author); use this mode only for free-form item data. Params under items[]. actorIdentifier (exact name or ID) is always required — find it with list-actors / get-actor.

Create a multi-page journal (quest log, handout, lore, GM notes) from STRUCTURED typed blocks — a STRUCTURING tool, it never writes the words. You pass pages of blocks (heading / lead / paragraph / readaloud / gmnote / list / grid / html); the tool renders them in the house style and sets per-page visibility (playerVisible -> players can observe a handout; omit -> GM-only). Compose the prose yourself (that's the journal-builder skill's job). For plain raw-HTML pages use create-journal instead.

Append a link from a quest journal to a REAL world NPC: resolves the actor, inserts a Foundry @UUID[Actor.id]{Name} enricher link (clickable on render) in a GM note, labelled with the relationship. Refuses an unknown NPC (no dead links) — create the actor first.

Append a new styled section to a quest/journal page from typed blocks (e.g. a heading "Session 3" + paragraphs of what happened) — the §8 session-log/progress path. You supply the words as blocks; the tool styles + appends them. By default appends to the first text page; use pageId to target a page, or newPageName to start a new page. Structuring only.

List all journal entries, or read a specific journal/page. Without parameters: lists all journals with their pages (id, name, type). With journalId: reads the journal's first text page content and shows all available pages. With journalId + pageId: reads a specific page's full content.

Search through all pages of all journal entries for specific content or keywords. Returns which specific page matched, so you can read it with list-journals using journalId + pageId.

Create a generic multi-page JournalEntry from caller-supplied pages. Each page is either a TEXT page ({name, content} — HTML, Foundry v13 ProseMirror) or an IMAGE page ({name, kind:"image", src, caption?} — a picture page, e.g. a map legend key), so an image-only journal builds in one call. Unlike create-quest-journal (styled blocks, auto-folders), this takes explicit pages and only folders when folderName is given. Per-page playerVisible exposes a handout; otherwise GM-only.

Generic JournalEntry update: rename the entry (name) and/or set page content. Content replaces the target page — pass pageId to target a specific page, newPageName to add a new page, or neither to update the first text page. For quest-style append updates use update-quest-journal instead. GM-only.

Flip one journal PAGE between player-visible (a handout players can OBSERVE) and GM-only, WITHOUT rewriting its content. Sets the page ownership default. Use this to reveal/hide an existing page — e.g. a page that came up GM-only from an append — instead of rebuilding the whole journal. GM-only.

Delete ONE page from a JournalEntry by page id (from list-journals), leaving the rest of the entry intact. Use to remove a stray/mistaken page instead of deleting and rebuilding the whole journal. GM-only.

Permanently delete one or more JournalEntry documents by exact id or exact name. STRICT resolution — no fuzzy/substring matching. GM-only.

Set ownership permissions for actors. Use permissionLevel OWNER/OBSERVER/LIMITED to grant access, or NONE to remove it. Supports individual assignments like "Make John the owner of Aragorn" and bulk operations like "Give the party observer access to all friendly NPCs".

List current ownership permissions for actors, showing which players have what access levels.

Plane B (file channel, read-only). List the immediate contents of a directory under the Foundry Data/ root over WebDAV (folders + files, with size / type / public URL). Use to browse uploaded assets, e.g. worlds/your-world/assets/audio. Empty/omitted path lists the Data/ root.

Plane B (file channel, read-only). Report whether a single path under the Foundry Data/ root exists, and (for files) its size, content-type, last-modified, and public HTTPS URL. A cheap existence/metadata check before uploading or linking.

Plane B (file channel, read-only). Download a file from under the Foundry Data/ root (over WebDAV) to a local path on this machine. For grabbing an existing asset to inspect or re-process.

Plane B (file channel, write). Upload an ASSET (map/token/audio/handout image) from a local file to the Foundry data area over WebDAV and return its public HTTPS URL, so large media bypass the bridge entirely. Missing parent folders are created automatically. ASSETS ONLY — never world-DB files (LevelDB writes while the server runs corrupt it; such paths are refused). PRIVACY: anything under Data/ is served publicly with no auth — do not upload anything sensitive. Requires MOLTEN_WEBDAV_PASSWORD.

Plane B (file channel, write). Recursively upload a LOCAL directory tree of ASSETS to the Foundry data area over WebDAV, preserving the subtree layout (each file → remoteRoot/), creating parent folders as needed. Use for BULK imports — a scene pack's images, a tiles folder — instead of one upload-asset per file. Skips files that already exist unless overwrite:true; optional includeExt filter (e.g. ["webp"]). ASSETS ONLY — refuses live world-DB paths. Reports uploaded/skipped/error counts. PRIVACY: anything under Data/ is served publicly with no auth. Requires MOLTEN_WEBDAV_PASSWORD.

Plane B (file channel, write). Create a folder (and any missing parents) under the Foundry Data/ root over WebDAV. Idempotent — succeeds if the folder already exists. Refuses paths inside a live world DB. Requires MOLTEN_WEBDAV_PASSWORD.

Plane B (file channel, write). Delete a file under the Foundry Data/ root over WebDAV. REFERENCE-AWARE: consults find-asset-references first and REFUSES if any scene/actor/journal/playlist still points at it (pass force:true to override). Deleting a directory requires recursive:true. Refuses live world-DB paths. Requires MOLTEN_WEBDAV_PASSWORD.

Plane B (file channel, write). Move/rename a file under the Foundry Data/ root over WebDAV; missing destination parent folders are created automatically. REFERENCE-AWARE: by default REFUSES with a report if anything references the source (moving would break those pointers). Pass relink:true to move AND rewrite all references (old→new), or force:true to move without relinking. Refuses live world-DB paths. Requires MOLTEN_WEBDAV_PASSWORD.

Plane B (file channel, write). Copy a file under the Foundry Data/ root over WebDAV; missing destination parent folders are created automatically. (Copying does not affect existing references, so no reference check is needed.) Refuses live world-DB destination paths. Requires MOLTEN_WEBDAV_PASSWORD.

Plane B (file channel). Return the public HTTPS URL for a file under the Foundry Data/ root. Pure mapping (no network): everything under Data/ is served at the server root (DESIGN §6), e.g. Data/worlds/w/maps/x.jpg → /worlds/w/maps/x.jpg. Useful for turning an uploaded/known asset path into a link Foundry or a player can load.

Reference integrity. Find every world document (scenes, actors, items, journals, playlists, macros, roll tables) that references a given asset path under Data/. Use this BEFORE deleting or moving a file to see what would break. Read-only.

Reference integrity. Rewrite every reference from one asset path to another (e.g. after moving/renaming a file) so nothing breaks. Pass dryRun:true to preview the documents that would change without writing. GM-only.

Composition. Set an actor's portrait image, and by default its prototype token art too, from a Data-relative path. The portrait (actor.img) must be a STILL image; pass tokenImagePath to give the prototype TOKEN an animated video (.webm/.mp4) while keeping a still portrait (the JB2A-effect pattern). GM-only.

Composition. Append an image page to a journal entry from a Data-relative image path, with an optional caption. GM-only by default; set playerVisible to expose it as a handout.

Read a Tom-Cartos-style Foundry SCENE-PACK MODULE off disk (a module.json + LevelDB/NeDB compendium packs) and return its era-normalized documents for import. OFF-LINE and Node-only: it reads files, never the live world. Detects the pack's Foundry era from field shape (older v10/NeDB vs newer v13/LevelDB), extracts each Scene (dimensions, grid, background, thumbnail, walls, lights, regions/teleporters) and JournalEntry (pages), strips cli pack artifacts, and — when given the destination root the skill chose — emits per-asset path REWRITE HINTS (the module-relative %-encoded src → a clean Data-relative path). Also discovers any standalone TILE images the pack ships (building/prop pieces with a Tile_<W>x<H> grid footprint in the name, not referenced by any scene) so the skill can make them available for the GM to drop onto scenes. The heavy per-scene walls/lights/regions are written to PAYLOAD FILES and referenced by placeablesPath (NOT inline — the response cap truncates them at scene scale); pass that path to create-scene, which reads it server-side. The skill then uploads the assets, recreates the scenes/journals, and (modern packs) remaps the cross-scene teleporters. Handles all eras: modern v13/LevelDB (via the @foundryvtt/foundryvtt-cli child process) AND legacy v10/NeDB .db (parsed directly — no cli needed). The full manifest is PAGED to fit the response cap: returns totalScenes + a page of scenes + nextOffset (call again with offset until null). Pass index:true first for a tiny names-only survey of the whole pack (variant planning + dedup) before paging the heavy import.

Create a Foundry Scene from a Data-relative background image path (e.g. an uploaded map). Width/height auto-detect from the image when omitted. Places it in a folder (created if absent) and sets navigation (false = a DM-only scene off the player nav bar) in the same call. AUTO-GENERATES the navigation thumbnail from the background (Foundry-native) when no explicit thumb is given — no more thumbnail-less scenes. Optionally set grid size/type/distance/units/color/alpha, token vision, fog mode, lighting (darkness, global light, or a whole environment{}/fog{} mood object + saved camera for pack imports), weather, a linked playlist/journal, a nav thumbnail, padding, provenance flags, and activate it. Can also IMPORT walls + ambient lights from a map sidecar JSON (the walls/lights arrays many battlemaps ship alongside the image): pass them and they are placed on the new scene (legacy or v14 shapes both accepted, normalized to v14). GM-only.

List Scene documents with id, name, active flag, dimensions, grid size, and background path. Optionally filter by name substring or show only the active scene.

Update an existing Scene document — rename, swap its background image (Data-relative path), toggle navigation, set the navigation label, change dimensions/grid (size/type/distance/units)/padding, token vision, fog mode, lighting (darkness, global light), weather, a nav thumbnail, or the linked playlist/journal ("" clears a link). Also (parity with create-scene) deep-merges a full environment{}/fog{} mood object, re-points the saved camera (initial{x,y,scale}), or re-stamps document flags on an existing scene. Scene-document only: never touches placeables (walls/lights/tokens) and never activates the scene. GM-only.

Permanently delete one or more Scene documents by exact id or exact name. STRICT resolution — no fuzzy/substring matching. GM-only.

Read a scene's live PADDED-CANVAS geometry (by id or exact name): total width/height, the background rect within the padding (sceneX/sceneY/sceneWidth/sceneHeight), grid size/distance, and rows/columns. A scene insets its background by a padding border, so a placeable's canvas pixel is NOT just gridCell×size — use sceneX/sceneY to offset. Feeds the legend→pins cell→px math. Works on any scene (no need to activate it).

Render a scene in the headless bridge and capture a PNG to a local file — visual QA for imports/maps. Views the scene, waits for the WebGL canvas to draw, fits the whole map into the viewport (or keeps the saved camera with fit:false), and optionally draws numbered markers over each map-note pin (mark:true) to check legend-pin placement (a view-only overlay, no document changes). Returns the file path + scene metadata; open/read that file to view the image. GM-only.

Place one or more TILES (props, roof/overhead pieces, decals, video overlays) on a scene from Data-relative image paths. A tile's on-map SIZE is width/height in canvas pixels; x/y are the absolute-canvas-pixel top-left (see get-scene-dimensions for padding-aware cell→px math). Optionally set rotation, alpha, elevation, sort, texture tint/fit/scale, roof occlusion (occlusionMode: 1 fade / 4 radial so it fades when a token walks under), light/weather restrictions, video loop/autoplay/volume, hidden, locked. Per-tile error isolation; a 404 texture keeps the path but warns. Returns created ids. GM-only.

List every Tile on a scene — id, position (x/y), size (width/height), rotation, elevation, sort, texture src, image scale, hidden/locked. Read-only; the inspect step before update-tiles / delete-tiles (you need the ids + current values to edit).

Edit one or more placed TILES by id (from list-tiles). RESIZE via width/height (the tile's on-map size — this is "tile scale"); MOVE via x/y; also rotation, alpha, elevation, sort, texture src/tint/fit/scaleX/scaleY (image zoom within the frame), occlusion, light/weather restrictions, video, hidden, locked. Patches only the fields you pass; unresolved ids are reported, not fatal. GM-only.

Delete one or more Tiles from a scene by id (from list-tiles). Missing ids are reported, never fatal. GM-only.

Place one or more AMBIENT LIGHTS (torches, braziers, magical glows) on a scene. x/y are the light CENTER in absolute canvas pixels; dim/bright are radii in grid-distance units (feet), NOT pixels. Set color, alpha (tint intensity), angle (cone), luminosity, attenuation (edge softness), an animation (animationType "torch"/"flame"/"pulse" + speed/intensity for flicker), and a darkness activation range (darknessMin ~0.1 so a torch only lights once the scene dims). walls confines it, vision lets it grant sight. Per-light error isolation. Returns created ids. GM-only.

List every AmbientLight on a scene — id, center (x/y), rotation, dim/bright radii, color, cone angle, animation type, hidden, walls/vision. Read-only; the inspect step before update-lights / delete-lights.

Edit one or more placed AMBIENT LIGHTS by id (from list-lights): MOVE via x/y, change dim/bright radii, color, alpha, angle, luminosity, attenuation, the animation (animationType/Speed/Intensity — e.g. add torch flicker), the darkness activation range, walls/vision, hidden. Emission fields nest under config internally — patches only the fields you pass, so a partial change never wipes the rest. Unresolved ids reported. GM-only.

Delete one or more AmbientLights from a scene by id (from list-lights). Missing ids are reported, never fatal. GM-only.

Place one or more positional AMBIENT SOUNDS on a scene (a crackling hearth, a waterfall, dripping cave water) from Data-relative audio paths. x/y are the emitter CENTER in absolute canvas pixels; radius is in grid-DISTANCE units (feet), NOT pixels. Optionally set volume, repeat (loop), walls (muffle through walls), easing (fade by distance), a darkness activation range (night-only sounds), and listener effects (baseEffect/muffledEffect, e.g. "lowpass"). A 404 audio path keeps the path but warns. Distinct from a scene playlist: this is a point emitter players walk into. Returns created ids. GM-only.

List every AmbientSound on a scene — id, name, center (x/y), radius, audio path, volume, repeat/walls/easing flags, darkness range, base effect. Read-only; the inspect step before update-sounds / delete-sounds.

Edit one or more placed AMBIENT SOUNDS by id (from list-sounds): MOVE via x/y, resize the audible radius, swap the track (path), change volume/repeat/walls/easing, the darkness activation range, or the listener effects. Patches only the fields you pass. Unresolved ids reported, never fatal. GM-only.

Delete one or more AmbientSounds from a scene by id (from list-sounds). Missing ids are reported, never fatal. GM-only.

Place one or more DRAWINGS (GM annotation shapes: secret-area boxes, trap outlines, zone labels) on a scene. x/y are the TOP-LEFT origin in absolute canvas pixels; pick a shapeType — rectangle/ellipse (width+height), circle (radius), or polygon (flat relative points list). Style with stroke (width/color/alpha), fill (fillType 1 solid / 2 pattern + fillTexture), and an optional centered text label (fontSize/textColor). hidden:true keeps it GM-only; interface:true floats it above fog. The default stroke makes a bare shape visible as an outline. Per-drawing error isolation. Returns created ids. GM-only.

List every Drawing on a scene — id, origin (x/y), shape type + dimensions (width/height/radius/pointCount), rotation, label text, fill type, stroke color, hidden/locked/interface. Read-only; the inspect step before update-drawings / delete-drawings.

Edit one or more placed DRAWINGS by id (from list-drawings): MOVE via x/y, RESIZE via width/height/radius or replace polygon points, restyle stroke/fill, change or clear the text label (text:""), toggle hidden/locked/interface. The shape KIND cannot change — delete and recreate for that. Patches only the fields you pass. GM-only.

Delete one or more Drawings from a scene by id (from list-drawings). Missing ids are reported, never fatal. GM-only.

Create one or more WALL segments on a scene — surgical additions (block a corridor, add a door/secret door) to walls normally drawn in the app or shipped by a map pack. Each wall is a segment x0,y0→x1,y1 (or c:[4]) in absolute canvas pixels. Channels: move (0/20), light/sight/sound (0 none / 10 limited / 20 normal / 30 proximity / 40 distance — omitted channels default to 20 blocking), dir (one-way), door (1 door / 2 secret) + ds (state) + doorSound, and proximity thresholds. Per-wall error isolation. Returns created ids. GM-only.

List walls on a scene — id, segment c:[x0,y0,x1,y1], move/sight/light/sound channels, one-way dir, door kind + state + sound. A populated scene carries HUNDREDS of walls: pass doorsOnly:true to get just the doors (the usual edit loop). Read-only; the inspect step before update-walls / delete-walls.

Edit one or more WALLS by id (from list-walls): flip a door to secret (door:2), open/close/LOCK it (ds: 0/1/2), change what it blocks (move/light/sight/sound: 0 none / 10 limited / 20 normal / 30 proximity / 40 distance), set one-way dir, doorSound, or proximity thresholds; MOVE by giving the full segment (all of x0,y0,x1,y1 or c:[4] — a wall never half-moves). Patches only the fields you pass; an off-enum value skips that patch with a warning. GM-only.

Delete one or more Walls from a scene by id (from list-walls) — e.g. open up a sealed passage. Missing ids are reported, never fatal. GM-only.

List every PLACED TOKEN on a scene (by id or exact name — any scene, not just the active one) — id, name, position (x/y), size, rotation, elevation, hidden, disposition, actorId, art src + scale, lockRotation. Read-only; the inspect step that feeds update-token / delete-tokens. The token ids also work as the actorIdentifier of the actor tools (get-actor, update-actor, update-actor-item, remove-from-actor, add-item/add-feature, import-item, manage-activity/-effect, apply-condition) — targeting a token id edits THAT instance's own delta, the way to re-gear/wound ONE placed copy of an unlinked NPC (base-actor edits never reach tokens already on a scene).

Place one or more actors' tokens on a scene (batch encounter prep — e.g. drop the whole hobgoblin band on the bridge). Each entry names an actor (id or EXACT name) + an absolute canvas-pixel x/y; the token is built from the actor's PROTOTYPE (so the house token defaults — auto-rotate, ring, disposition — carry over), with optional per-copy hidden/elevation/rotation/name/disposition overrides. Repeat an actor for several copies. The GM can always drag tokens in the app instead — this is for scripted/batch placement. GM-only.

Edit one or more PLACED tokens on a scene — a token INSTANCE already dropped on the map, NOT the actor's prototype token (that's update-actor). Resolve the scene by id/exact name (default: the ACTIVE scene), then target tokens by tokenIds and/or actorIds (an actor id OR exact name — updates EVERY placed copy of that actor, e.g. all "Dead Guard" corpses). Patch any of: rotation (or randomizeRotation for an independent per-token angle), scale (token art size — sets texture.scaleX/scaleY together), elevation, hidden, lockRotation, x/y, name, displayName (nameplate visibility), displayBars (resource-bar visibility), bar1/bar2 (which resource each bar tracks — the health bar is bar1 = attributes.hp), ring (dynamic token ring on/off), and hp (this token's CURRENT hit points, per-token on its own delta — so two copies of one actor can be wounded differently, which update-actor cannot do) — all matched tokens update in one batch. GOTCHA handled for you: a token whose actor had auto-rotate OFF carries lockRotation:true, which HIDES a set rotation — so when you rotate a locked token the tool auto-unlocks it and warns. Reports matched/updated counts + any unresolved ids. GM-only.

Remove one or more PLACED tokens from a scene by token id (from list-tokens) — clears the map instance only; the sidebar actor survives (delete-actor removes that). Missing ids are reported, never fatal. GM-only.

Place map-note PINS on a scene, each linked to a JournalEntry (and optionally a specific page) — the deterministic half of the legend→GM-room-pins feature. Pass absolute canvas pixel x/y (see get-scene-dimensions for the padding-aware math), an optional label/icon/size, and the journal id|name. Per-note error isolation: a pin whose journal does not resolve is reported and skipped, not fatal. GM-only secrecy is the linked journal's ownership, not the pin; global only controls fog occlusion. Returns each created note id (for update-note/delete-note). GM-only.

List every MAP-NOTE PIN on a scene — id, position (x/y), label text, linked journal entryId/pageId, icon src + size, fog global, font. Read-only; the inspect step that feeds update-note / delete-note (create-scene-notes places them).

Nudge ONE existing map-note pin by id (the legend→pins review loop): move it (x/y), relabel it, resize/restyle its icon, toggle fog global, or re-point it to a different journal/page. Patches only the fields you pass; at least one is required. Strict scene + note-id resolution. GM-only.

Remove one or more map-note pins from a scene by note id (from create-scene-notes). Missing ids are reported, never fatal. GM-only.

Create one or more Regions on an EXISTING scene (the general primitive behind create-teleporter). Each region carries its v14 shapes whole (rectangle/ellipse/polygon in canvas px) plus optional color/visibility/behaviors. Behaviors pass through verbatim: a teleportToken here must already have system.destinations = ["Scene..Region."] (use create-teleporter for the two-new-region convenience). Returns the created region ids. GM-only.

List every Region on a scene — id, name, each shape's bounds, and any teleporter destinations. Read-only; use it to find region ids for update-region / delete-region.

Update ONE region by id: rename, recolor, change visibility, replace its shapes whole, or reshape to a single grid rectangle via the rect convenience (center px + cells + snap — the move/resize you'd do reviewing a teleporter). Patches only what you pass; behaviors are left untouched. GM-only.