<SYSTEM>This is the full developer documentation for declarative-hex-worlds</SYSTEM>

# declarative-hex-worlds

> Declarative, deterministic hex worlds for TypeScript games. Bootstrap KayKit assets in one command. First-class React + Three.js bindings.

## What you ship

[Section titled “What you ship”](#what-you-ship)

Declarative API

Describe what you want — a harbor with three depth tiers, a procedural forest, a road network connecting both. The library handles tile selection, connectivity, prop scatter, and validation. No imperative grid bookkeeping.

Deterministic by construction

Same seed, same output — byte-identical, across processes and platforms. Server-authoritative simulation, save-game replays, and cross-machine reproducibility all work out of the box.

First-class React + Three.js

Not optional peer-deps. The library tests against the versions it ships and exposes idiomatic hooks and scene helpers. Install one package and start rendering.

## Bootstrap in three steps

[Section titled “Bootstrap in three steps”](#bootstrap-in-three-steps)

1. **Install the package**

   ```bash
   pnpm add declarative-hex-worlds
   ```

2. **Fetch the FREE KayKit asset pack** (CC0-licensed; \~30 MB)

   ```bash
   pnpm exec declarative-hex-worlds bootstrap
   ```

   Downloads 221 GLTF models into `public/assets/models/addons/kaykit_medieval_hexagon_pack/`. SHA-256 sidecar verified.

3. **Render your first harbor**

   ```tsx
   import { Canvas } from '@react-three/fiber';
   import * as HexWorld from 'declarative-hex-worlds';


   const plan = HexWorld.createGameboardBuilder({
     seed: 'harbor-village-1',
     shape: { kind: 'rectangle', width: 6, height: 6 },
   }).build();


   const runtime = HexWorld.createGameboardRuntimeFromScenario({
     plan,
     scenario: { actors: [], quests: [] },
   });


   export function Harbor() {
     return (
       <HexWorld.GameboardProvider runtime={runtime}>
         <Canvas>{/* your three.js scene of rt.snapshot() */}</Canvas>
       </HexWorld.GameboardProvider>
     );
   }
   ```

## Explore the library

[Section titled “Explore the library”](#explore-the-library)

[Pieces & actors](/features/pieces-and-actors/)Declare buildings, units, decorations. The library spawns + binds them to ECS entities.

[Multi-depth stacks](/features/multi-depth-stacks/)Stacked terrain (water → land → cliff → peak) with validated transitions.

[Harbors](/features/harbors/)Sandy crescents, piers, fishing villages — composable harbor recipes.

[Bridges & connectors](/features/bridges-and-connectors/)Spans, ferries, roads — connectivity validation across biome edges.

[Quests](/features/quests/)Patrol routes, spawn groups, scripted scenarios. Deterministic replay.

[Determinism & replay](/features/determinism-replay/)The full seed → blueprint → scenario → simulation chain, byte-for-byte.

[Tile injection](/features/tile-injection/)Drop bespoke tiles into procedural maps without breaking constraints.

[Prop injection](/features/prop-injection/)Authored set-pieces (a watchtower, a graveyard) layered onto generated terrain.

[Cross-kit composition](/features/cross-kit-composition/)Mix the FREE pack with EXTRA-pack tiles or third-party GLTFs.

[Movement & patrols](/features/movement-and-patrols/)Actor movement, patrol routes, navigation predicates.

## Why this exists

[Section titled “Why this exists”](#why-this-exists)

Hex-grid games are simple in concept and a maintenance nightmare in code. Tile adjacency rules, biome blending, asset selection, deterministic seeding, multiplayer-safe replay — each is a small problem; all of them together is a six-month detour from shipping a game.

**declarative-hex-worlds** treats the whole stack as one declarative pipeline: recipe → blueprint → scenario → koota ECS world → React + Three.js render. You declare what you want and what’s allowed; the library decides what goes where, validates it, and gives you back a deterministic snapshot.

The hex-tile assets are the [KayKit Medieval Hexagon Pack](https://kaykit.itch.io/medieval-hexagon-pack) by [Kay Lousberg](https://kaylousberg.com/) — gorgeous, low-poly, CC0. The library bootstraps them at install time; the npm tarball stays small (\~2.3 MB) and asset licensing stays clean.

[Architecture](/about/architecture/)How recipe / blueprint / scenario / runtime fit together.

[Design rationale](/about/design/)Why determinism is the product, and why react+three are runtime deps.

[API reference](/reference/readme/)Every public symbol across the 21 subpath exports.

[CLI reference](/guides/cli-reference/)36 commands — bootstrap, validate, simulate, coverage, and more.

# Asset bootstrap

> Materialize the KayKit Medieval Hexagon GLTF asset tree under your app's asset root.

`declarative-hex-worlds` is an **asset-bootstrapping** library, not an asset-bundled one. The published npm tarball ships:

* The typed runtime, CLI, React + Three.js bindings.
* The FREE-edition `manifest.json` (metadata only — asset ids, paths, bounds, taxonomy, file sizes).

The KayKit GLTF binaries themselves (≈30 MB for FREE, more for EXTRA) are fetched at install time by the CLI `bootstrap` subcommand, or by calling the programmatic [`bootstrapKayKitAssets`](/reference/bootstrap/) API directly.

## Why bootstrap, not bundle?

[Section titled “Why bootstrap, not bundle?”](#why-bootstrap-not-bundle)

* **Keeps the npm tarball lean** (\~1 MB shipped vs 30+ MB if bundled).
* **Lets consumers re-use a single asset tree** across multiple apps via a shared `public/assets/models/` directory.
* **Avoids redistributing CC0 binary blobs** through npm’s CDN.
* **Supports the purchased EXTRA edition** without forcing every consumer to redistribute the larger archive.

## Quick start (FREE edition, from GitHub)

[Section titled “Quick start (FREE edition, from GitHub)”](#quick-start-free-edition-from-github)

```bash
pnpm add declarative-hex-worlds
pnpm exec declarative-hex-worlds bootstrap
```

The default `--out` heuristic detects:

1. `public/assets/models/` (Vite / Next.js convention) — preferred.
2. `assets/models/` (fallback).
3. The current working directory.

You can always pass `--out <path>` explicitly. After bootstrap, the tree lives at:

```text
<out>/addons/kaykit_medieval_hexagon_pack/
├── Assets/gltf/
│   ├── buildings/{blue,green,red,yellow,neutral}/...gltf
│   ├── decoration/{nature,props}/...gltf
│   └── tiles/{base,coast,rivers,roads}/...gltf
├── Textures/
│   └── hexagons_medieval.png
└── .bootstrap.json
```

## Downloadable default packs

[Section titled “Downloadable default packs”](#downloadable-default-packs)

Beyond the FREE tile pack, three first-class CC0 packs by [Kay Lousberg](https://kaylousberg.com) compose into a full game from defaults — a hex board, playable characters, and enemies. Fetch any of them by id:

`--out` names the raw-assets **root**; each pack lands in `<out>/<id>/`, so the default-source resolvers below always find it:

```bash
pnpm exec declarative-hex-worlds bootstrap --pack medieval-hexagon --out raw-assets
pnpm exec declarative-hex-worlds bootstrap --pack adventurers      --out raw-assets
pnpm exec declarative-hex-worlds bootstrap --pack skeletons        --out raw-assets
# → raw-assets/{medieval-hexagon,adventurers,skeletons}/
```

| Pack id            | Role   | Fills               |
| ------------------ | ------ | ------------------- |
| `medieval-hexagon` | tiles  | the terrain board   |
| `adventurers`      | models | playable characters |
| `skeletons`        | models | enemies             |

Packs are **never** tracked in git — keep `raw-assets/` gitignored. They download from their upstream GitHub archives on demand. Programmatically:

```ts
import {
  bootstrapPack,
  resolveDefaultPackKit,
  assertPackPresent,
} from 'declarative-hex-worlds/bootstrap';


// Fetch a pack (lands in raw-assets/adventurers/).
await bootstrapPack('adventurers', { rawAssetsRoot: 'raw-assets' });


// Compose defaults from whatever is downloaded.
for (const pack of resolveDefaultPackKit('raw-assets')) {
  if (pack.present) console.log(`${pack.id} → ${pack.dir}`);
}


// Or require one, failing clearly (with the fetch command) if it is missing.
const dir = assertPackPresent('skeletons', 'raw-assets');
```

## EXTRA edition (purchased)

[Section titled “EXTRA edition (purchased)”](#extra-edition-purchased)

The EXTRA edition is sold on [kaylousberg.itch.io](https://kaylousberg.itch.io) and ships extra `units/` GLTFs plus seasonal `hexagons_medieval_{Fall,Summer, Winter}.png` textures. Download the zip from itch.io, then:

```bash
pnpm exec declarative-hex-worlds bootstrap \
  --source zip \
  --zip ~/Downloads/KayKit_Medieval_Hexagon_Pack_1.0_EXTRA.zip \
  --edition extra \
  --out public/assets/models
```

The CLI auto-detects the edition from the zip’s layout markers and refuses to overwrite a FREE-shaped target with EXTRA content (and vice-versa).

## Reproducible bootstraps

[Section titled “Reproducible bootstraps”](#reproducible-bootstraps)

The integrity sidecar (`.bootstrap.json`) records:

* `schemaVersion` (currently `1.0.0`).
* `edition` (`free` or `extra`).
* `libraryVersion` (the library version that performed the bootstrap).
* `sourceUrl` (the GitHub tarball URL, or `file://` for zip sources).
* `fetchedAt` (ISO-8601 timestamp).
* `files[]` — sorted list of `{path, sha256, bytes}` for every mirrored file.

For deterministic CI builds, pass `fetchedAt` and `libraryVersion` to the programmatic API:

```ts
import { bootstrapKayKitAssets } from 'declarative-hex-worlds/bootstrap';


await bootstrapKayKitAssets({
  source: { kind: 'github', commit: 'main' }, // pin to a specific sha for reproducibility
  out: 'public/assets/models',
  fetchedAt: '2026-01-01T00:00:00.000Z',
  libraryVersion: '1.0.0',
});
```

## Verifying an existing bootstrap

[Section titled “Verifying an existing bootstrap”](#verifying-an-existing-bootstrap)

```bash
pnpm exec declarative-hex-worlds bootstrap --verify --out public/assets/models
```

Re-hashes every file recorded in `.bootstrap.json` and reports any drift (missing files, size mismatches, hash mismatches). Exits non-zero on drift — useful as a CI step before deploys.

## Wiring the runtime to your bootstrap target

[Section titled “Wiring the runtime to your bootstrap target”](#wiring-the-runtime-to-your-bootstrap-target)

Three ways to tell the loaders where your bootstrap target lives:

```ts
// 1. Per-call (most explicit)
import { resolveManifestAssetUrl, freeManifest } from 'declarative-hex-worlds';
const url = resolveManifestAssetUrl(freeManifest.assets[0], {
  bootstrapAssetRoot: '/app/public/assets/models',
});


// 2. Process-wide (app boot)
import { setGameboardAssetRoot } from 'declarative-hex-worlds';
setGameboardAssetRoot('/app/public/assets/models');


// 3. Environment variable (Node consumers)
//    HEX_WORLDS_ASSET_ROOT=/app/public/assets/models
```

Resolution priority: explicit `setGameboardAssetRoot` override → `globalThis.HEX_WORLDS_ASSET_ROOT` → `process.env.HEX_WORLDS_ASSET_ROOT` → default `public/assets/models`.

## Troubleshooting

[Section titled “Troubleshooting”](#troubleshooting)

### `bootstrap destination ... is not empty`

[Section titled “bootstrap destination ... is not empty”](#bootstrap-destination--is-not-empty)

The target already contains files. Pass `--force` to wipe and re-mirror, or pick a different `--out`.

### `zip contains the EXTRA edition but bootstrap was asked for FREE`

[Section titled “zip contains the EXTRA edition but bootstrap was asked for FREE”](#zip-contains-the-extra-edition-but-bootstrap-was-asked-for-free)

The zip’s layout markers identify it as EXTRA. Add `--edition extra` (and make sure you have a license / purchased copy).

### `failed to download KayKit FREE tarball ... unexpected status 404`

[Section titled “failed to download KayKit FREE tarball ... unexpected status 404”](#failed-to-download-kaykit-free-tarball--unexpected-status-404)

GitHub returned a non-2xx response. Common causes:

* Pinned `--commit <sha>` no longer exists (force-pushed or deleted).
* Temporary GitHub outage. Retry, or pass `--source zip` with a locally downloaded copy.

### `bootstrap verify FAILED ... hash mismatch`

[Section titled “bootstrap verify FAILED ... hash mismatch”](#bootstrap-verify-failed--hash-mismatch)

A file on disk no longer matches its recorded sha256. Either a deploy modified the tree (unlikely — the tree should be read-only after bootstrap) or disk corruption. Re-run `bootstrap --force` to restore.

### Runtime loads 404 — wrong asset root

[Section titled “Runtime loads 404 — wrong asset root”](#runtime-loads-404--wrong-asset-root)

The runtime falls back to `public/assets/models` if no override is configured. If you bootstrapped to `assets/models` or elsewhere, set `HEX_WORLDS_ASSET_ROOT` or call `setGameboardAssetRoot(...)` at boot.

## Programmatic API

[Section titled “Programmatic API”](#programmatic-api)

See the [`bootstrap` reference](/reference/bootstrap/) for the full surface, including the {@link BootstrapKayKitAssetsOptions}, {@link BootstrapResult}, and {@link BootstrapSidecar} types.

# Bindings and bundling

> Subpath imports, trait identity hazard, the first-class React + Three.js binding model.

## Subpath imports

[Section titled “Subpath imports”](#subpath-imports)

The library publishes \~40 subpaths under `package.json#exports`. Pick the one you need:

```ts
// Specific subpath — only that domain's symbols + its transitive deps land in your bundle
import { createGameboardBuilder } from 'declarative-hex-worlds/gameboard';
import { GameboardProvider, useGameboardRuntime } from 'declarative-hex-worlds/react';
import { loadGameboardPlacementObject } from 'declarative-hex-worlds/three';


// Umbrella — everything (use only for prototyping)
import * as lib from 'declarative-hex-worlds';
```

The umbrella re-exports everything from every sub-package; consumers prototyping in a sandbox can use it. For production code, prefer subpath imports — they let bundlers tree-shake aggressively because `sideEffects: false` is set on the package.

## React + Three.js are direct dependencies, not peer-deps

[Section titled “React + Three.js are direct dependencies, not peer-deps”](#react--threejs-are-direct-dependencies-not-peer-deps)

PRD invariant §5: `react`, `react-dom`, `three`, `koota`, `honeycomb-grid`, `seedrandom` are direct `dependencies`. The library is unusable without them; bundling them defensively is not a consumer choice.

Why this matters:

1. **No version skew between library code and consumer code.** A common peer-dep failure mode is the library being tested against React 18 while the consumer ships React 19; subtle hook behavior changes. With direct deps, the library pins what it tests against.
2. **No “did you remember to install React?” footgun.** `npm install declarative-hex-worlds` is enough.
3. **The library can ship binding implementations confidently.** `useGameboardRuntime()` knows it’s using the same React the library tested against.

If your app uses a different React version than the library, npm’s de-duplication generally resolves to your version (your `package.json` wins). For Three.js the same de-dup applies. The library tests against the latest patches of each major; check `package.json` for the current pin.

## Trait identity hazard (and why `splitting: true` matters)

[Section titled “Trait identity hazard (and why splitting: true matters)”](#trait-identity-hazard-and-why-splitting-true-matters)

The library’s koota traits (in `src/traits/`) are unique objects compared by reference, not name. If two chunks both define the same trait, koota treats them as different traits and your entities don’t match queries.

The library protects you by:

1. **Single `traits/` barrel.** Every trait declaration lives at `src/traits/<domain>.ts` and is re-exported from `src/traits/index.ts`. There’s only one declaration per trait.
2. **`splitting: true` in tsup.** Each subpath becomes its own chunk, but shared dependencies (including trait declarations) land in shared chunks. The trait identity test (Epic E4) imports the same trait from `/koota` and from the umbrella and asserts reference-equality.

For consumers: import traits through whichever subpath is convenient. They’re the same object regardless of import path. The E4 test pins this; if it ever fails, your bundle has a chunk-splitting bug.

## When you need to extend with custom traits

[Section titled “When you need to extend with custom traits”](#when-you-need-to-extend-with-custom-traits)

```ts
import { trait } from 'koota';
import { type GameboardActor } from 'declarative-hex-worlds/actors';


// Define a custom trait
const Inventory = trait<{ items: string[] }>();


// Spawn an entity with both library traits and your custom trait
const myActor = world.spawn(GameboardActor({ id: 'player', team: 'players' }), Inventory({ items: [] }));
```

Your custom traits should live in your own module, exported once. If you split them across files via re-exports, ensure `splitting: true` in your bundler too (most modern bundlers do this by default).

## SSR / server-side rendering

[Section titled “SSR / server-side rendering”](#ssr--server-side-rendering)

The `react` subpath uses hooks that need the React provider. The `three` subpath has DOM dependencies (canvas, WebGL) and shouldn’t import in SSR. The pattern:

```ts
// pages/board.tsx (Next.js)
import dynamic from 'next/dynamic';
const Board = dynamic(() => import('./Board'), { ssr: false });
```

The library doesn’t ship an SSR-safe variant; render boards client-only.

## Bundle size

[Section titled “Bundle size”](#bundle-size)

The umbrella is \~250 KB minified (most of that is the FREE manifest literal — 16k LOC of asset metadata). Subpath imports cut to whatever you actually use; `/coordinates` alone is \~8 KB.

The bundled FREE manifest is the product (PRD §B2 rejection): it’s why “install + bootstrap + render” is a 30-line quickstart. If you don’t want it in your bundle, import `/coordinates`, `/gameboard`, etc. directly and load the manifest yourself via `loadFreeManifest()` (B2b).

## Subpath table

[Section titled “Subpath table”](#subpath-table)

See the [API reference](/reference/) for the full list. Every subpath has its own page documenting what it exports.

# CLI Reference

> Every command, flag, and option accepted by the declarative-hex-worlds CLI binary.

import { Aside } from ‘@astrojs/starlight/components’;

This page is autogenerated from \`src/cli/cli.ts\` by \`scripts/generate-cli-reference.ts\`. Edits land in the source, not here.

The library ships a Node CLI binary named `declarative-hex-worlds`. Invoke via `pnpm exec declarative-hex-worlds <command>` or `npx declarative-hex-worlds <command>`.

## Bootstrap first

[Section titled “Bootstrap first”](#bootstrap-first)

Most commands operate against a local FREE or EXTRA pack tree. Before any tile / asset command, run:

```bash
pnpm exec declarative-hex-worlds bootstrap
```

This downloads the KayKit FREE pack and mirrors it flat under `./models/` (default). See the [bootstrap guide](/guides/bootstrap/) for source modes, integrity verification, and customizing the output directory.

## Full usage

[Section titled “Full usage”](#full-usage)

```plaintext
declarative-hex-worlds <command> [options]


Commands:
  doctor    Report local source and docs status
  validate    Validate local FREE or EXTRA source counts
  manifest    Generate a manifest JSON from a source folder
  validate-manifest    Validate a generated manifest JSON and optionally write a normalized copy
  analyze    Analyze tile bounds, grid scale, row spacing, and warnings
  declarations    Emit tile declarations from a source folder, manifest, or registry
  guide-permutations    Emit guide-labeled road, river, crossing, and coast permutation metadata
  guide-scenarios    Emit extracted guide-page scenario metadata and validate page assets
  guide-usages    Emit renderer-ready page-level guide asset occurrence metadata
  guide-render-requests    Emit URL-resolved guide render request queues and optional page groups
  guide-apis    Emit public API to guide-page and asset coverage metadata
  guide-assets    Emit asset id to guide-page, API, docs, and visual coverage metadata
  guide-roles    Emit public role to guide-page, asset, and API coverage metadata
  coverage    Emit release-readiness coverage JSON or Markdown
  blueprint    Compile high-level 2.5D board intent to a recipe, plan, scenario, and diagnostics
  summarize-plan    Summarize terrain, placement, feature, asset, and local-only usage in a plan, recipe, scenario, or blueprint
  summarize-scenario    Summarize board, actor, spawn, patrol, quest, and local-only usage in a scenario
  pieces    Validate piece declarations and optionally emit seeded piece fill rules
  place-piece    Inspect and append one declared piece against a saved GameboardPlan, recipe, or scenario
  validate-plan    Validate a GameboardPlan JSON with optional registry rules
  analyze-layout    Analyze seeded layout fill rules against a saved GameboardPlan, recipe, or scenario
  spawn-groups    Plan separated spawn groups and route diagnostics against a plan, recipe, or scenario
  patrol-routes    Plan NPC/enemy patrol waypoints and segment diagnostics against a plan, recipe, or scenario
  patrol-script    Create executable simulation command steps from planned patrol routes and actor assignments
  validate-recipe    Validate a GameboardRecipe JSON and optionally compile it to a plan
  validate-scenario    Validate a GameboardScenario JSON and optionally compile its plan
  validate-simulation    Validate a GameboardScenario simulation script without executing it
  snapshot    Emit a neutral ECS interop snapshot from a plan, recipe, or scenario
  simulate-scenario    Run a GameboardScenario simulation script and emit event records, final plan, or ECS interop
  compatibility    Analyze one external GLB/GLTF for hex-tile compatibility and placement suggestions
  piece    Emit a custom piece declaration from an external GLB/GLTF compatibility scan
  pieces-from-assets    Scan GLB/GLTF files and emit custom piece declarations plus compatibility summaries
  bind    Scan an assets directory and emit a Zod-validated AssetSourceSpec JSON (the agent path — no prompts)
  init    Interactively bind an assets directory to an AssetSourceSpec (the human path — a TTY wizard)
  web    Bind an assets directory via a local web form (the visual path — a loopback config UI)
  extract    Copy GLTF assets and write a manifest to an output folder (alias: ingest)
  bootstrap    Materialize KayKit GLTF assets under a consumer asset root (PRD RB)


Run `declarative-hex-worlds <command> --help` for that command's full flag reference.


Global options (accepted by every command):
  --source <path>
      Override the source root every command resolves against (default: ./references/KayKit_Medieval_Hexagon_Pack_1.0_<FREE|EXTRA>, chosen by --edition).
  --edition free|extra
      Pack edition used to pick the default --source root and validate assets (default: free).


Options:
  --actorId <id>
  --allowExpectationFailures
  --allowInvalid
  --allowUnknownAssetIds <comma,separated,assetIds>
  --allowUnknownAssets
  --asset <path>
  --asset-root <path>
  --assetBaseUrl <url-or-path>
  --assetEdition free|extra|all
  --assetId <assetId>
  --assetId <comma,separated,ids>
  --assetIdPrefix <prefix>
  --assetIds <comma,separated,assetIds>
  --assetIds <comma,separated,ids>
  --assets <comma,separated,paths>
  --assetScope free|extra|all
  --assignments <path>
  --blueprint <path>
  --boardForwardEdge 0..5
  --categories <comma,separated,values>
  --category tiles|buildings|decoration|units
  --checksPassed
  --cols <n> --rows <n>
  --commit <sha>
  --config <path>
  --count <number>
  --coverage
  --creator <name>
  --defaultTerrain <terrain>
  --dir <path>
  --edition free|extra
  --editionScope free|extra|mixed|reference
  --emitRules
  --emitSourceUrls
  --excludeActors
  --excludePlacements
  --excludeQuests
  --excludeSpawnGroups
  --excludeTags <comma,separated,tags>
  --excludeTimeline
  --faction <faction>
  --failOnBlockedQuest
  --failOnWarning
  --fill <number>
  --force
  --format json
  --format markdown|json
  --freeOnly
  --generatedAt <iso-timestamp>
  --grouped
  --groups
  --groups <path>
  --guideRole <comma,separated,roles>
  --harbors <number>
  --height <number>
  --id <id>
  --idPrefix <prefix>
  --ids <comma,separated,pieceIds>
  --include-source-formats
  --includeAbsolutePaths
  --includeGroups
  --includeInterop
  --includePlan
  --includeRecipe
  --includeReport
  --includeReports
  --includeScenario
  --includeScenarioInspection
  --includeTreatments
  --intendedRole tile|prop|structure|unit
  --json
  --license <license>
  --manifest <path>
  --markdown
  --maxCount <number>
  --maxElevation <number>
  --minCount <number>
  --minimumEdition free|extra|all
  --mode per-piece|pool
  --modelForward +z|-z|+x|-x
  --name <name>
  --out <path>
  --outInterop <path>
  --outJson <path>
  --outManifest <path>
  --outMarkdown <path>
  --outPlan <path>
  --outRecipe <path>
  --outScenario <path>
  --outScenarioInspection <path>
  --overrides <path>
  --pack <id>
  --page <comma,separated,numbers>
  --pieceId <id>
  --pieceIdPrefix <prefix>
  --pieceOverrides <path>
  --pieces <path>
  --pieceSourceRoot <url-or-path>
  --pieceSourceRoots <json-path-or-inline-json>
  --plan <path>
  --port <n>
  --publicApi <comma,separated,api-names>
  --publicApi <comma,separated,names>
  --radius <number>
  --recipe <path>
  --registry <path>
  --requiresExtra
  --role <comma,separated,asset-treatment-roles>
  --role <comma,separated,roles>
  --role surface|building|unit|prop|tree|scatter|landmark|custom
  --roles <comma,separated,roles>
  --rounds <number>
  --routeId <id>
  --routes <path>
  --ruleIdPrefix <prefix>
  --rules <path>
  --scenario <comma,separated,ids>
  --scenario <path>
  --scenarioId <comma,separated,ids>
  --script <path>
  --seed <seed>
  --shape rectangle|hexagon
  --source github|zip
  --sourcePack <name>
  --sources <comma,separated,sources>
  --spawnCount <number>
  --spawnEdgePadding <number>
  --spawnMinDistance <number>
  --spawnSeed <seed>
  --tags <comma,separated,tags>
  --textureSet <texture-set>
  --topAssetLimit <number>
  --topAssets <number>
  --towns <number>
  --unencodedSourceUrls
  --verify
  --waterFill <number>
  --width <number>
  --width, --height, --radius, --seed, --faction, --textureSet, --defaultTerrain, --waterFill, --maxElevation, --towns, --harbors, --shape
  --zip <path>
```

## Common command recipes

[Section titled “Common command recipes”](#common-command-recipes)

### Doctor

[Section titled “Doctor”](#doctor)

Report local source + docs status. Useful first-time setup sanity check:

```bash
declarative-hex-worlds doctor
```

### Validate a FREE pack

[Section titled “Validate a FREE pack”](#validate-a-free-pack)

```bash
declarative-hex-worlds validate --edition free --source ./references/KayKit_Medieval_Hexagon_Pack_1.0_FREE
```

### Compile a blueprint to a plan + scenario

[Section titled “Compile a blueprint to a plan + scenario”](#compile-a-blueprint-to-a-plan--scenario)

```bash
declarative-hex-worlds blueprint \
  --blueprint ./blueprint.json \
  --outScenario ./scenario.json \
  --includeScenario
```

### Run a simulation script

[Section titled “Run a simulation script”](#run-a-simulation-script)

```bash
declarative-hex-worlds simulate-scenario \
  --scenario ./scenario.json \
  --script ./simulation.script.json \
  --rounds 10
```

### Emit coverage ledger

[Section titled “Emit coverage ledger”](#emit-coverage-ledger)

```bash
declarative-hex-worlds coverage \
  --checksPassed \
  --outJson docs/release-readiness.json \
  --outMarkdown docs/release-readiness.md
```

## Safe output paths

[Section titled “Safe output paths”](#safe-output-paths)

Every `--out*` flag goes through `safeResolveOutput` ([PRD C1](https://github.com/jbcom/declarative-hex-worlds/blob/main/docs/PRD/1.0.md#c1)). Paths that escape the current working directory throw before any write happens. `extract` refuses to wipe a non-empty destination unless `--force` is passed.

Setting \`HEX\_WORLDS\_OUT\_ROOT\` to an absolute path widens the output jail beyond the working directory. Use only in controlled CI environments. Never set it to \`/\` or any ancestor of sensitive paths — the CLI will write there without further restrictions.

## JSON flag schemas and error contracts

[Section titled “JSON flag schemas and error contracts”](#json-flag-schemas-and-error-contracts)

Several flags accept JSON values directly or via a file path:

* **`--pieceSourceRoots`** — `{ "sourceRoots": { "<packName>": "<absoluteOrRelativePath>" } }`. Keys must match `[A-Za-z0-9_:-]+`; any key that is a prototype-pollution vector (`__proto__`, `constructor`, `prototype`) is rejected before the object is parsed.
* **`--pieceOverrides`** — `{ "overrides": { "<pieceId>": { "footprint"?: ..., "criteria"?: ..., "tags"?: string[], "metadata"?: ... } } }`.
* **`--pieces`** (all `pieces*` commands) — a path to a JSON file produced by `pieces-from-assets`. Not accepted as inline JSON.

All JSON parsing errors surface as `GameboardCliError` with a descriptive message on stderr. Exit code is always non-zero on error.

## Errors

[Section titled “Errors”](#errors)

CLI errors are `GameboardCliError` instances ([PRD D2](https://github.com/jbcom/declarative-hex-worlds/blob/main/docs/PRD/1.0.md#d2)). The library’s error taxonomy is documented in the [errors reference](/reference/errors/).

# Determinism Contract

> Seed model, replay guarantees, where Date / Math.random are (and aren't) permitted.

The library is deterministic: identical inputs (seed + scenario + script) produce **byte-identical outputs** across processes and platforms. This is PRD invariant §1, and the test suite has a cross-process gate (Epic E1) that spawns N subprocesses and asserts byte-identity to keep it honest.

## What “deterministic” means here

[Section titled “What “deterministic” means here”](#what-deterministic-means-here)

Given the same:

* **Seed** (`"my-seed"` or any string passed to `createSeededGameboardPlan(...)`).
* **Scenario** (the compiled `GameboardScenario` JSON).
* **Simulation script** (the array of timed commands).

…you get the same:

* Generated plan: same tiles in the same order, same placements with the same attributes.
* Simulation event records: same event types, same ordering, same timestamps.
* Runtime snapshots: same actor positions, quest progress, patrol waypoints.

…across Node 22 and Node 24, across macOS / Linux / Windows, across `pnpm test` runs separated by months.

## The seed model

[Section titled “The seed model”](#the-seed-model)

The library uses [seedrandom](https://github.com/davidbau/seedrandom) under `src/scenario/recipe.ts` and `src/coordinates/layout.ts`. Every random decision threads through a `seedrandom.PRNG` instance derived from the seed:

```ts
import { createSeededGameboardPlan } from 'declarative-hex-worlds';


const plan = createSeededGameboardPlan({
  seed: 'harbor-village-7',
  shape: { kind: 'rectangle', width: 8, height: 6 },
});
// `plan.tiles`, `plan.placements`, `plan.warnings` — all reproducible from "harbor-village-7"
```

Pass the same seed twice, get the same plan twice. Pass a different seed, get a different plan.

## Where `Date.now`, `Math.random`, `performance.now` are forbidden

[Section titled “Where Date.now, Math.random, performance.now are forbidden”](#where-datenow-mathrandom-performancenow-are-forbidden)

PRD invariant §2: **never** in `src/`. Their use would inject system entropy into a “pure” runtime function and break the determinism contract.

The lint config (`biome.json`) has `noGlobalIsNan`-style rules to flag them. The single exception is `src/cli/cli.ts:2296` where a `generatedAt` timestamp gets a default from `Date.now()` — and even there it’s overridable via `--generatedAt`.

## What about RNG inside three.js / koota?

[Section titled “What about RNG inside three.js / koota?”](#what-about-rng-inside-threejs--koota)

Neither uses non-determinism in their hot paths. three’s geometry math is pure; koota’s entity allocation is monotonic. The library doesn’t expose three’s `Math.random()`-using helpers (e.g. `THREE.MathUtils.randFloat`) — consumers who want random placement decisions thread through the library’s seeded helpers instead.

## Replay guarantees

[Section titled “Replay guarantees”](#replay-guarantees)

For a saved scenario, you can:

1. **Re-derive the plan** from `scenario.seed + scenario.shape`.
2. **Re-execute the simulation** from `scenario.scriptId + scenario.script`.
3. **Snapshot the world** at any tick and serialize via `runtime.snapshot()` → matches across runs.

This is what enables:

* Server-authoritative simulation (server runs the script; clients verify by replay).
* Save games (just store the seed + script, not the world state).
* Cross-process testing (the E1 gate compares JSON snapshots across spawned subprocesses).

## What breaks determinism (and what doesn’t)

[Section titled “What breaks determinism (and what doesn’t)”](#what-breaks-determinism-and-what-doesnt)

| Breaks ❌                                                                            | Safe ✅                                                             |
| ----------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
| Mutating `freeManifest` at runtime                                                  | Reading `freeManifest`                                             |
| Calling `Date.now()` inside a custom action                                         | Passing a fixed `generatedAt` ISO string to CLI commands           |
| Iterating `Map` / `Set` insertion-order across processes with different V8 versions | The library uses `[...].sort()` everywhere insertion-order matters |
| Concurrent `async` decisions in actions                                             | Synchronous action handlers (the default)                          |
| Using `JSON.stringify(...)` on objects with circular refs                           | `structuredClone(plan)` (B8 replaced the JSON dance)               |

## Testing your own determinism

[Section titled “Testing your own determinism”](#testing-your-own-determinism)

```ts
import { createSeededGameboardPlan } from 'declarative-hex-worlds';
import { expect, test } from 'vitest';


test('same seed → same plan', () => {
  const a = createSeededGameboardPlan({ seed: 's', shape: { kind: 'rectangle', width: 4, height: 4 } });
  const b = createSeededGameboardPlan({ seed: 's', shape: { kind: 'rectangle', width: 4, height: 4 } });
  expect(JSON.stringify(a)).toBe(JSON.stringify(b));
});
```

For cross-process determinism, mirror what the E1 gate does: spawn `node --eval` subprocesses with the same script, capture stdout, compare.

## Future

[Section titled “Future”](#future)

PRD Epic E1 ratchets this from a contract to a permanent test gate. Once E1 lands, every PR runs the cross-process determinism check.

# Error taxonomy

> GameboardError + 6 subclasses for structured catch-by-instanceof handling.

import { Aside } from ‘@astrojs/starlight/components’;

The library throws structured errors. Every library-originated throw is a `GameboardError` subclass — consumers can branch on `instanceof` without regex’ing messages.

Implementation: \`src/errors/index.ts\`. 152 throw sites migrated (PRD D2). Messages are stable; consumers that match on text today keep working.

## The hierarchy

[Section titled “The hierarchy”](#the-hierarchy)

```ts
import {
  GameboardError,              // base — catch this to handle ANY library error
  GameboardValidationError,    // input data failed structural validation
  GameboardManifestError,      // manifest is malformed / version-incompatible
  GameboardScenarioError,      // scenario JSON / blueprint / recipe failed to compile or load
  GameboardRuntimeError,       // runtime hit unrecoverable state
  GameboardCliError,           // CLI got invalid flags / illegal output paths
  GameboardIoError,            // ingest / bootstrap / filesystem couldn't proceed
} from 'declarative-hex-worlds/errors';
```

Or import from the umbrella:

```ts
import { GameboardValidationError } from 'declarative-hex-worlds';
```

## Domain → subclass mapping

[Section titled “Domain → subclass mapping”](#domain--subclass-mapping)

| Source domain                                                                                                                                                                                                                                                                   | Subclass                   | Examples                                                        |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------- | --------------------------------------------------------------- |
| `src/rules/**` (plan + scenario validation)                                                                                                                                                                                                                                     | `GameboardValidationError` | rule conflict, blocked tile, invalid placement                  |
| `src/manifest/**` shape errors                                                                                                                                                                                                                                                  | `GameboardManifestError`   | unknown asset category, invalid export identifier               |
| `src/ingest/**` filesystem                                                                                                                                                                                                                                                      | `GameboardIoError`         | missing GLTF source directory                                   |
| `src/cli/commands/bootstrap/**`                                                                                                                                                                                                                                                 | `GameboardIoError`         | archive-zip download failure, zip extract failure               |
| `src/scenario/**` (recipe / blueprint / catalog)                                                                                                                                                                                                                                | `GameboardScenarioError`   | scenario did not compile, recipe missing tiles                  |
| `src/gameboard/**`, `src/coordinates/**`, `src/simulation/**`, `src/koota/**`, `src/systems/**`, `src/movement/**`, `src/patrol/**`, `src/quests/**`, `src/actors/**`, `src/pieces/**`, `src/interop/**`, `src/commands/**`, `src/selectors/**`, `src/three/**`, `src/react/**` | `GameboardRuntimeError`    | unknown entity, broken trait shape, missing tile at coordinates |
| `src/cli/cli.ts`                                                                                                                                                                                                                                                                | `GameboardCliError`        | missing required flag, illegal path                             |

## Usage patterns

[Section titled “Usage patterns”](#usage-patterns)

**Catch a specific category**:

```ts
import { GameboardValidationError, validateGameboardScenario } from 'declarative-hex-worlds';


try {
  const scenario = validateGameboardScenario(input);
} catch (e) {
  if (e instanceof GameboardValidationError) {
    console.error('Scenario invalid:', e.message);
    showUserError(e.message);
    return;
  }
  throw e; // re-throw anything unexpected
}
```

**Catch any library error** (separate from genuine bugs like `TypeError`, `ReferenceError`):

```ts
import { GameboardError } from 'declarative-hex-worlds';


try {
  await loadAndRun(input);
} catch (e) {
  if (e instanceof GameboardError) {
    // library-originated — show a UI error
    showError(`Library error: ${e.message}`);
    return;
  }
  // genuine bug — let it propagate to the global handler
  throw e;
}
```

**Walk the cause chain** (when `cause` is set):

```ts
try {
  await bootstrapKayKitAssets(options);
} catch (e) {
  if (e instanceof GameboardError && e.cause instanceof Error) {
    console.error('Cause:', e.cause.message);
  }
  throw e;
}
```

## Constructor shape

[Section titled “Constructor shape”](#constructor-shape)

Every subclass takes `(message, options?)`:

```ts
class GameboardError extends Error {
  constructor(message: string, options?: { cause?: unknown });
}
```

Subclasses set `.name` to their class name automatically (`new.target.name`), so error logs read `GameboardValidationError: ...` not `Error: ...`.

## Stable messages

[Section titled “Stable messages”](#stable-messages)

PRD D2 preserved every existing error message verbatim during the migration. Consumers that grep messages today keep working. Don’t change a message lightly; treat it as part of the API contract.

## What’s NOT a `GameboardError`

[Section titled “What’s NOT a GameboardError”](#whats-not-a-gameboarderror)

* `TypeError` / `ReferenceError` / `RangeError` — these are bugs in the library or in your usage. Report them.
* Errors thrown from npm dependencies (`tar`, `seedrandom`, etc.) — these propagate unwrapped.
* Browser-side errors from `three.js` / WebGL — these are rendering issues, not library logic errors.

# Get started

> Install, bootstrap the FREE asset pack, and render your first hexagon gameboard.

`declarative-hex-worlds` is a deterministic, ECS-driven, React + Three.js library for building hex-grid games on top of the KayKit Medieval Hexagon GLTF pack. This page gets you from `pnpm add` to rendered hexes in under five minutes.

## 1. Install + bootstrap

[Section titled “1. Install + bootstrap”](#1-install--bootstrap)

```bash
pnpm add declarative-hex-worlds
pnpm exec declarative-hex-worlds bootstrap
```

The library ships the typed runtime + the FREE manifest metadata; the GLTF binaries themselves are downloaded at install time from the [KayKit upstream GitHub repo](https://github.com/KayKit-Game-Assets/KayKit-Medieval-Hexagon-Pack-1.0) by the `bootstrap` subcommand. The default `--out` heuristic targets `public/assets/models/` (Vite / Next.js convention); see [Asset bootstrap](/guides/asset-bootstrap/) for the full workflow including the EXTRA edition and reproducible-build options.

After bootstrap, your asset tree looks like:

```text
public/assets/models/addons/kaykit_medieval_hexagon_pack/
├── Assets/gltf/...     # 221 .gltf + .bin files
├── Textures/...
└── .bootstrap.json     # integrity sidecar
```

## 2. Point the runtime at your bootstrap target

[Section titled “2. Point the runtime at your bootstrap target”](#2-point-the-runtime-at-your-bootstrap-target)

```ts
import { setGameboardAssetRoot } from 'declarative-hex-worlds';


// Call once at app boot:
setGameboardAssetRoot('/public/assets/models');
```

Or set `HEX_WORLDS_ASSET_ROOT` in your environment — the runtime falls through `override → globalThis → process.env → 'public/assets/models'` default.

## 3. Build a deterministic gameboard

[Section titled “3. Build a deterministic gameboard”](#3-build-a-deterministic-gameboard)

```ts
import {
  buildGameboardBlueprint,
  createGameboardWorldFromScenario,
} from 'declarative-hex-worlds';


// One-call: shape + seed → fully populated scenario.
const { scenario } = buildGameboardBlueprint({
  shape: { kind: 'rectangle', width: 12, height: 8 },
  seed: 'tutorial-island',
});


// Spawn into a Koota world with traits, occupancy, navigation graphs, etc.
const runtime = createGameboardWorldFromScenario(scenario);
```

`buildGameboardBlueprint` compiles biome fills, mountain ranges, towns, roads, rivers, harbors, and prop clusters into a `GameboardScenario` that the Koota runtime can spawn deterministically from a seed.

## 4. Render with the React + Three.js bindings

[Section titled “4. Render with the React + Three.js bindings”](#4-render-with-the-react--threejs-bindings)

```tsx
import { Canvas } from '@react-three/fiber';
import { GameboardScene } from 'declarative-hex-worlds/react';


export function App({ runtime }: { runtime: GameboardRuntime }) {
  return (
    <Canvas camera={{ position: [0, 12, 18], fov: 50 }}>
      <ambientLight intensity={0.4} />
      <directionalLight position={[10, 20, 10]} intensity={1.5} />
      <GameboardScene runtime={runtime} />
    </Canvas>
  );
}
```

React + Three.js are first-class runtime dependencies (not optional peers), so the bindings work without any extra installs.

## 5. Next steps

[Section titled “5. Next steps”](#5-next-steps)

* [Asset bootstrap](/guides/asset-bootstrap/) — full bootstrap workflow, including EXTRA edition, reproducible builds, and `--verify`.
* [KayKit upstream layout](/guides/kaykit-upstream-layout/) — the on-disk shape the bootstrap step mirrors.
* [CLI reference](/guides/cli-reference/) — every CLI subcommand and flag.
* [`declarative-hex-worlds`](/reference/) — typed API reference.

# Guide scenario coverage

> Per-page KayKit user-guide coverage matrix.

The KayKit user guide is decomposed into 19 source-page scenarios. This page is the human-facing map for those scenarios; the machine-readable source remains `listKayKitGuideScenarios()`, `describeKayKitGuideScenarioCoverage()`, `listKayKitGuideScenarioAssetUsages()`, `listKayKitGuideScenarioAssetRenderRequests()`, `listKayKitGuideScenarioAssetRenderGroups()`, `listKayKitGuideAssetCoverages()`, `listKayKitGuideRoleCoverages()`, `listKayKitGuidePublicApiCoverages()`, and the `guide-scenarios` / `guide-usages` / `guide-render-requests` / `guide-assets` / `guide-roles` / `guide-apis` CLI commands.

Use this page when deciding whether a guide image has public API treatment, docs, and visual review coverage. Use the catalog API or CLI when a tool needs exact asset ids or public treatment records.

```sh
node dist/cli.js guide-scenarios --markdown > docs/guides/guide-scenario-coverage.md
node dist/cli.js guide-scenarios --page 15 --includeTreatments --json
node dist/cli.js guide-usages --page 16,17,18 --json
node dist/cli.js guide-render-requests --page 16,17,18 --assetBaseUrl /assets/extra --includeGroups --out /tmp/kaykit-guide-render-requests.json
node dist/cli.js guide-assets --assetId hex_road_M --json
node dist/cli.js guide-roles --role prop --json
node dist/cli.js guide-apis --publicApi GameboardBuilder.addHarbor --json
```

## Coverage Contract

[Section titled “Coverage Contract”](#coverage-contract)

* Every extracted guide page has exactly one `page-NN-*` scenario.
* Every scenario lists its source PNG, edition scope, public API surfaces, docs, and visual artifacts.
* Every FREE and local EXTRA asset id appears in at least one scenario unless it is a reference-only license/supporter page with no assets.
* Every asset-bearing scenario can be expanded into public treatment records with `listKayKitGuideScenarioTreatments(id)`.
* Every page-level asset occurrence can be expanded into renderer-ready usage records with `listKayKitGuideScenarioAssetUsages()`.
* Every FREE and local EXTRA asset id can be inverted back to pages/APIs/docs and screenshots with `listKayKitGuideAssetCoverages()`.
* Every public treatment role can be inverted back to pages/assets/APIs with `listKayKitGuideRoleCoverages()`.
* Every public API string in a scenario can be inverted back to pages/assets with `listKayKitGuidePublicApiCoverages()`.

## Page Matrix

[Section titled “Page Matrix”](#page-matrix)

### Page 01 - Overview And License Contract

[Section titled “Page 01 - Overview And License Contract”](#page-01---overview-and-license-contract)

* Scenario: `page-01-overview-and-license`
* Edition: `reference`
* Source image: `docs/assets/kaykit-guide/pages/page-01.png`
* Asset coverage: 0 unique, 0 FREE, 0 EXTRA, 0 occurrences
* Roles: reference-only
* Public API treatment: `freeManifest`, `listKayKitAssetPublicTreatments`, `listKayKitGuideScenarios`
* Visual artifacts: `docs/assets/kaykit-guide/montage.png`, `docs/assets/kaykit-guide/pages/page-01.png`
* Docs: `README.md`, `NOTICE.md`, `docs/pillars/00-library-charter.md`

### Page 02 - Buildings, Props, And Factions

[Section titled “Page 02 - Buildings, Props, And Factions”](#page-02---buildings-props-and-factions)

* Scenario: `page-02-buildings-props-and-factions`
* Edition: `mixed`
* Source image: `docs/assets/kaykit-guide/pages/page-02.png`
* Asset coverage: 164 unique, 119 FREE, 45 EXTRA, 164 occurrences
* Roles: `faction-building`, `neutral-structure`, `prop`
* Public API treatment: `GameboardBuilder.addBridge`, `GameboardBuilder.addConstructionSite`, `GameboardBuilder.addFactionBuilding`, `GameboardBuilder.addFlag`, `GameboardBuilder.addFortification`, `GameboardBuilder.addHarbor`, `GameboardBuilder.addNeutralStructure`, `GameboardBuilder.addProp`, `GameboardBuilder.addPropCluster`, `GameboardBuilder.addSettlement`, `GameboardBuilder.addSiegeProjectile`, `createGameboardLayoutFillRuleFromPiece`, `createGameboardPlanFromRecipe`, `factionBuildingAssetId`, `flagAssetId`, `listPropClusterAssets`
* Visual artifacts: `tests/browser/__screenshots__/free-guide-page-nature-stacks-buildings-props.png`, `tests/browser/__screenshots__/extra-local-all-buildings-factions-neutral-harbors.png`
* Docs: `docs/pillars/02-asset-taxonomy.md`, `docs/guides/public-api.md`

### Page 03 - Road Variations

[Section titled “Page 03 - Road Variations”](#page-03---road-variations)

* Scenario: `page-03-road-variations`
* Edition: `free`
* Source image: `docs/assets/kaykit-guide/pages/page-03.png`
* Asset coverage: 15 unique, 15 FREE, 0 EXTRA, 15 occurrences
* Roles: `road-tile`
* Public API treatment: `GameboardBuilder.addRoadPath`, `listRoadGuidePermutations`, `selectRoadVariant`, `selectRoadVariantByLabel`
* Visual artifacts: `tests/browser/__screenshots__/free-guide-roads-all-labels-rotations.png`
* Docs: `docs/pillars/01-tiles-connectivity.md`, `docs/pillars/04-visual-verification.md`

### Page 04 - River Variations

[Section titled “Page 04 - River Variations”](#page-04---river-variations)

* Scenario: `page-04-river-variations`
* Edition: `free`
* Source image: `docs/assets/kaykit-guide/pages/page-04.png`
* Asset coverage: 30 unique, 30 FREE, 0 EXTRA, 30 occurrences
* Roles: `river-tile`
* Public API treatment: `GameboardBuilder.addRiverPath`, `listRiverCrossingGuidePermutations`, `listRiverCurvyGuidePermutations`, `listRiverGuidePermutations`, `selectRiverCrossingVariant`, `selectRiverVariant`, `selectRiverVariantByLabel`
* Visual artifacts: `tests/browser/__screenshots__/free-guide-rivers-all-labels-rotations-water-waterless.png`, `tests/browser/__screenshots__/free-guide-river-curvy-crossings-all-modes.png`
* Docs: `docs/pillars/01-tiles-connectivity.md`, `docs/pillars/04-visual-verification.md`

### Page 05 - Nature And Decoration Contents

[Section titled “Page 05 - Nature And Decoration Contents”](#page-05---nature-and-decoration-contents)

* Scenario: `page-05-nature-contents`
* Edition: `free`
* Source image: `docs/assets/kaykit-guide/pages/page-05.png`
* Asset coverage: 77 unique, 68 FREE, 9 EXTRA, 77 occurrences
* Roles: `nature-decoration`, `prop`
* Public API treatment: `GameboardBuilder.addFlag`, `GameboardBuilder.addForest`, `GameboardBuilder.addHarbor`, `GameboardBuilder.addHill`, `GameboardBuilder.addMountainStack`, `GameboardBuilder.addNature`, `GameboardBuilder.addProp`, `GameboardBuilder.addPropCluster`, `GameboardBuilder.scatterDecorations`, `createGameboardBlueprintRecipe`, `createGameboardLayoutFillRuleFromPiece`, `flagAssetId`, `listPropClusterAssets`
* Visual artifacts: `tests/browser/__screenshots__/free-guide-page-nature-stacks-buildings-props.png`, `tests/browser/__screenshots__/extra-local-all-decoration-nature-props.png`
* Docs: `docs/pillars/02-asset-taxonomy.md`, `docs/pillars/05-koota-runtime-rules.md`

### Page 06 - Nature Usage Guide

[Section titled “Page 06 - Nature Usage Guide”](#page-06---nature-usage-guide)

* Scenario: `page-06-nature-usage`
* Edition: `free`
* Source image: `docs/assets/kaykit-guide/pages/page-06.png`
* Asset coverage: 42 unique, 42 FREE, 0 EXTRA, 42 occurrences
* Roles: `nature-decoration`
* Public API treatment: `GameboardBuilder.addForest`, `GameboardBuilder.addHill`, `GameboardBuilder.addMountainStack`, `GameboardBuilder.addNature`, `GameboardBuilder.scatterDecorations`, `createGameboardBlueprintPlan`, `createGameboardLayoutArchetypeRegistry`, `createGameboardLayoutFillRuleFromPiece`, `inspectGameboardBlueprint`
* Visual artifacts: `tests/browser/__screenshots__/free-guide-page-nature-stacks-buildings-props.png`, `tests/browser/__screenshots__/free-generated-piece-recipe.png`
* Docs: `docs/pillars/02-asset-taxonomy.md`, `docs/pillars/05-koota-runtime-rules.md`

### Page 07 - Water Usage Guide

[Section titled “Page 07 - Water Usage Guide”](#page-07---water-usage-guide)

* Scenario: `page-07-water-usage`
* Edition: `free`
* Source image: `docs/assets/kaykit-guide/pages/page-07.png`
* Asset coverage: 44 unique, 44 FREE, 0 EXTRA, 44 occurrences
* Roles: `base-tile`, `coast-tile`, `neutral-structure`, `river-tile`
* Public API treatment: `GameboardBuilder.addBridge`, `GameboardBuilder.addHarbor`, `GameboardBuilder.addNeutralStructure`, `GameboardBuilder.addRiverPath`, `GameboardBuilder.setCoastEdges`, `GameboardBuilder.setTerrain`, `GameboardBuilder.setTileAsset`, `createGameboardPlanFromRecipe`, `createGameboardPlanFromTiles`, `listCoastGuidePermutations`, `listRiverCrossingGuidePermutations`, `listRiverCurvyGuidePermutations`, `listRiverGuidePermutations`, `selectCoastVariant`, `selectCoastVariantByLabel`, `selectRiverCrossingVariant`, `selectRiverVariant`, `selectRiverVariantByLabel`
* Visual artifacts: `tests/browser/__screenshots__/free-guide-coasts-all-labels-rotations-water-waterless.png`, `tests/browser/__screenshots__/free-guide-rivers-all-labels-rotations-water-waterless.png`, `tests/browser/__screenshots__/extra-harbor-gameboard.png`
* Docs: `docs/pillars/01-tiles-connectivity.md`, `docs/pillars/04-visual-verification.md`

### Page 08 - Taller Hex Tiles

[Section titled “Page 08 - Taller Hex Tiles”](#page-08---taller-hex-tiles)

* Scenario: `page-08-taller-hex-tiles`
* Edition: `free`
* Source image: `docs/assets/kaykit-guide/pages/page-08.png`
* Asset coverage: 3 unique, 3 FREE, 0 EXTRA, 3 occurrences
* Roles: `base-tile`, `support-tile`
* Public API treatment: `GameboardBuilder.addElevationRamp`, `GameboardBuilder.addMountainStack`, `GameboardBuilder.setElevation`, `GameboardBuilder.setTileAsset`, `createGameboardBlueprintRecipe`, `createGameboardPlanFromRecipe`
* Visual artifacts: `tests/browser/__screenshots__/free-guide-page-nature-stacks-buildings-props.png`, `tests/browser/__screenshots__/free-gameboard-recipe.png`, `tests/browser/__screenshots__/free-blueprint-builder-showcase.png`
* Docs: `docs/pillars/01-tiles-connectivity.md`, `docs/pillars/05-koota-runtime-rules.md`

### Page 09 - World Design Example

[Section titled “Page 09 - World Design Example”](#page-09---world-design-example)

* Scenario: `page-09-world-design-example`
* Edition: `free`
* Source image: `docs/assets/kaykit-guide/pages/page-09.png`
* Asset coverage: 61 unique, 61 FREE, 0 EXTRA, 61 occurrences
* Roles: `base-tile`, `nature-decoration`, `neutral-structure`, `road-tile`
* Public API treatment: `GameboardBuilder.addBridge`, `GameboardBuilder.addForest`, `GameboardBuilder.addHill`, `GameboardBuilder.addMountainStack`, `GameboardBuilder.addNature`, `GameboardBuilder.addNeutralStructure`, `GameboardBuilder.addRoadPath`, `GameboardBuilder.scatterDecorations`, `GameboardBuilder.setTerrain`, `GameboardBuilder.setTileAsset`, `createGameboardBuilder`, `createGameboardLayoutFillRuleFromPiece`, `createGameboardPlanFromRecipe`, `createGameboardPlanFromTiles`, `createGameboardRuntimeFromScenario`, `createMedievalShowcaseBlueprintRecipe`, `createSeededGameboardPlan`, `listRoadGuidePermutations`, `selectRoadVariant`, `selectRoadVariantByLabel`, `selectSpawnCoordinates`
* Visual artifacts: `tests/browser/__screenshots__/free-gameboard-recipe.png`, `tests/browser/__screenshots__/free-blueprint-builder-showcase.png`, `tests/browser/__screenshots__/free-seeded-gameboard.png`, `tests/browser/__screenshots__/simple-rpg-fixed-completed.png`, `tests/browser/__screenshots__/extra-blueprint-biome-transition-showcase.png`
* Docs: `docs/guides/recipes-scenarios-and-simulation.md`, `docs/pillars/05-koota-runtime-rules.md`

### Page 10 - Floating Islands

[Section titled “Page 10 - Floating Islands”](#page-10---floating-islands)

* Scenario: `page-10-floating-islands`
* Edition: `free`
* Source image: `docs/assets/kaykit-guide/pages/page-10.png`
* Asset coverage: 45 unique, 45 FREE, 0 EXTRA, 45 occurrences
* Roles: `base-tile`, `nature-decoration`, `support-tile`
* Public API treatment: `GameboardBuilder.addElevationRamp`, `GameboardBuilder.addForest`, `GameboardBuilder.addHill`, `GameboardBuilder.addMountainStack`, `GameboardBuilder.addNature`, `GameboardBuilder.scatterDecorations`, `GameboardBuilder.setElevation`, `GameboardBuilder.setTileAsset`, `createGameboardBlueprintPlan`, `createGameboardLayoutFillRuleFromPiece`, `createGameboardPlanFromRecipe`, `createHexagonGameboardGrid`
* Visual artifacts: `tests/browser/__screenshots__/free-seeded-hex-gameboard.png`, `tests/browser/__screenshots__/free-guide-page-nature-stacks-buildings-props.png`
* Docs: `docs/pillars/02-asset-taxonomy.md`, `docs/pillars/05-koota-runtime-rules.md`

### Page 11 - Biomes

[Section titled “Page 11 - Biomes”](#page-11---biomes)

* Scenario: `page-11-biomes`
* Edition: `extra`
* Source image: `docs/assets/kaykit-guide/pages/page-11.png`
* Asset coverage: 1 unique, 0 FREE, 1 EXTRA, 1 occurrence
* Roles: `transition-tile`
* Public API treatment: `GameboardBuilder.addTransition`, `createGameboardBlueprintRecipe`, `createGameboardPlanFromRecipe`, `inspectGameboardBlueprint`, `textureFileName`, `validateGameboardRecipe`
* Visual artifacts: `tests/browser/__screenshots__/extra-local-all-tiles-guide-and-transitions.png`, `tests/browser/__screenshots__/extra-seasonal-textures.png`, `tests/browser/__screenshots__/extra-blueprint-biome-transition-showcase.png`
* Docs: `docs/pillars/03-editions-and-ingest.md`, `docs/guides/rendering-assets-and-external-packs.md`

### Page 12 - Alternate Textures

[Section titled “Page 12 - Alternate Textures”](#page-12---alternate-textures)

* Scenario: `page-12-alternate-textures`
* Edition: `extra`
* Source image: `docs/assets/kaykit-guide/pages/page-12.png`
* Asset coverage: 1 unique, 0 FREE, 1 EXTRA, 1 occurrence
* Roles: `transition-tile`
* Public API treatment: `GameboardBuilder.addTransition`, `createGameboardPlanFromRecipe`, `createManifestBundle`, `declarative-hex-worlds manifest`, `selectManifestAssets`, `textureFileName`, `validateGameboardRecipe`
* Visual artifacts: `tests/browser/__screenshots__/extra-seasonal-textures.png`, `tests/browser/__screenshots__/extra-local-all-tiles-guide-and-transitions.png`
* Docs: `docs/pillars/03-editions-and-ingest.md`, `docs/guides/rendering-assets-and-external-packs.md`

### Page 13 - Transition Tiles

[Section titled “Page 13 - Transition Tiles”](#page-13---transition-tiles)

* Scenario: `page-13-transition-tiles`
* Edition: `extra`
* Source image: `docs/assets/kaykit-guide/pages/page-13.png`
* Asset coverage: 1 unique, 0 FREE, 1 EXTRA, 1 occurrence
* Roles: `transition-tile`
* Public API treatment: `GameboardBuilder.addTransition`, `analyzeHexTileRegistry`, `createGameboardBlueprintRecipe`, `createGameboardPlanFromRecipe`, `createMedievalShowcaseBlueprintRecipe`, `declareHexTile`, `validateGameboardRecipe`, `validateGameboardRecipeGeneration`
* Visual artifacts: `tests/browser/__screenshots__/extra-local-all-tiles-guide-and-transitions.png`, `tests/browser/__screenshots__/extra-seasonal-textures.png`, `tests/browser/__screenshots__/extra-blueprint-biome-transition-showcase.png`
* Docs: `docs/pillars/01-tiles-connectivity.md`, `docs/pillars/03-editions-and-ingest.md`

### Page 14 - Units

[Section titled “Page 14 - Units”](#page-14---units)

* Scenario: `page-14-units`
* Edition: `extra`
* Source image: `docs/assets/kaykit-guide/pages/page-14.png`
* Asset coverage: 137 unique, 0 FREE, 137 EXTRA, 137 occurrences
* Roles: `colored-unit-part`, `neutral-unit-part`
* Public API treatment: `GameboardBuilder.addUnit`, `GameboardBuilder.addUnitPreset`, `coloredUnitAssetId`, `neutralUnitAssetId`, `spawnGameboardActor`
* Visual artifacts: `tests/browser/__screenshots__/extra-local-all-units-full-accent-neutral-siege.png`, `tests/browser/__screenshots__/simple-rpg-local-third-party-assets.png`
* Docs: `docs/pillars/02-asset-taxonomy.md`, `docs/guides/runtime-integration.md`

### Page 15 - Shipyard, Harbors, And Ports

[Section titled “Page 15 - Shipyard, Harbors, And Ports”](#page-15---shipyard-harbors-and-ports)

* Scenario: `page-15-shipyard-harbors`
* Edition: `mixed`
* Source image: `docs/assets/kaykit-guide/pages/page-15.png`
* Asset coverage: 25 unique, 14 FREE, 11 EXTRA, 25 occurrences
* Roles: `coast-tile`, `faction-building`, `prop`
* Public API treatment: `GameboardBuilder.addFactionBuilding`, `GameboardBuilder.addHarbor`, `GameboardBuilder.addProp`, `GameboardBuilder.addPropCluster`, `GameboardBuilder.addUnitPreset`, `GameboardBuilder.setCoastEdges`, `createGameboardLayoutFillRuleFromPiece`, `externalAssetSpawnOptions`, `factionBuildingAssetId`, `listCoastGuidePermutations`, `listPropClusterAssets`, `selectCoastVariant`, `selectCoastVariantByLabel`
* Visual artifacts: `tests/browser/__screenshots__/extra-harbor-gameboard.png`, `tests/browser/__screenshots__/extra-local-all-buildings-factions-neutral-harbors.png`
* Docs: `docs/pillars/02-asset-taxonomy.md`, `docs/pillars/03-editions-and-ingest.md`

### Page 16 - Stables And Horses

[Section titled “Page 16 - Stables And Horses”](#page-16---stables-and-horses)

* Scenario: `page-16-stables-and-horses`
* Edition: `extra`
* Source image: `docs/assets/kaykit-guide/pages/page-16.png`
* Asset coverage: 155 unique, 11 FREE, 144 EXTRA, 155 occurrences
* Roles: `colored-unit-part`, `faction-building`, `neutral-structure`, `neutral-unit-part`, `prop`
* Public API treatment: `GameboardBuilder.addFactionBuilding`, `GameboardBuilder.addFortification`, `GameboardBuilder.addNeutralStructure`, `GameboardBuilder.addProp`, `GameboardBuilder.addPropCluster`, `GameboardBuilder.addSettlement`, `GameboardBuilder.addUnit`, `GameboardBuilder.addUnitPreset`, `coloredUnitAssetId`, `createGameboardLayoutFillRuleFromPiece`, `createGameboardPlanFromRecipe`, `factionBuildingAssetId`, `listPropClusterAssets`, `neutralUnitAssetId`, `recommendExternalAssetFacing`, `spawnGameboardActor`
* Visual artifacts: `tests/browser/__screenshots__/extra-local-all-units-full-accent-neutral-siege.png`, `tests/browser/__screenshots__/extra-local-all-decoration-nature-props.png`
* Docs: `docs/pillars/02-asset-taxonomy.md`, `docs/guides/rendering-assets-and-external-packs.md`

### Page 17 - Workshop And Siege Units

[Section titled “Page 17 - Workshop And Siege Units”](#page-17---workshop-and-siege-units)

* Scenario: `page-17-workshop-and-siege`
* Edition: `extra`
* Source image: `docs/assets/kaykit-guide/pages/page-17.png`
* Asset coverage: 170 unique, 22 FREE, 148 EXTRA, 170 occurrences
* Roles: `colored-unit-part`, `faction-building`, `neutral-structure`, `neutral-unit-part`, `prop`
* Public API treatment: `GameboardBuilder.addConstructionSite`, `GameboardBuilder.addFactionBuilding`, `GameboardBuilder.addFortification`, `GameboardBuilder.addNeutralStructure`, `GameboardBuilder.addProp`, `GameboardBuilder.addPropCluster`, `GameboardBuilder.addSettlement`, `GameboardBuilder.addSiegeProjectile`, `GameboardBuilder.addUnit`, `GameboardBuilder.addUnitPreset`, `coloredUnitAssetId`, `createGameboardLayoutFillRuleFromPiece`, `createGameboardPlanFromRecipe`, `executeGameboardInteractionCommand`, `factionBuildingAssetId`, `listPropClusterAssets`, `neutralUnitAssetId`, `planGameboardInteractionCommand`, `spawnGameboardActor`
* Visual artifacts: `tests/browser/__screenshots__/extra-local-all-buildings-factions-neutral-harbors.png`, `tests/browser/__screenshots__/extra-local-all-units-full-accent-neutral-siege.png`
* Docs: `docs/pillars/02-asset-taxonomy.md`, `docs/guides/runtime-integration.md`

### Page 18 - Unit Combinations

[Section titled “Page 18 - Unit Combinations”](#page-18---unit-combinations)

* Scenario: `page-18-unit-combinations`
* Edition: `extra`
* Source image: `docs/assets/kaykit-guide/pages/page-18.png`
* Asset coverage: 137 unique, 0 FREE, 137 EXTRA, 137 occurrences
* Roles: `colored-unit-part`, `neutral-unit-part`
* Public API treatment: `GameboardBuilder.addUnit`, `GameboardBuilder.addUnitPreset`, `coloredUnitAssetId`, `createGameboardRuntimeFromScenario`, `neutralUnitAssetId`, `spawnGameboardActor`
* Visual artifacts: `tests/browser/__screenshots__/extra-local-all-units-full-accent-neutral-siege.png`, `tests/browser/__screenshots__/simple-rpg-seeded-completed.png`
* Docs: `docs/pillars/02-asset-taxonomy.md`, `docs/guides/recipes-scenarios-and-simulation.md`

### Page 19 - Supporters And Attribution

[Section titled “Page 19 - Supporters And Attribution”](#page-19---supporters-and-attribution)

* Scenario: `page-19-supporters-and-attribution`
* Edition: `reference`
* Source image: `docs/assets/kaykit-guide/pages/page-19.png`
* Asset coverage: 0 unique, 0 FREE, 0 EXTRA, 0 occurrences
* Roles: reference-only
* Public API treatment: `NOTICE.md`, `listKayKitGuideScenarios`, `package.json files`
* Visual artifacts: `docs/assets/kaykit-guide/pages/page-19.png`, `NOTICE.md`
* Docs: `NOTICE.md`, `docs/pillars/00-library-charter.md`, `README.md`

## Asset Coverage Query

[Section titled “Asset Coverage Query”](#asset-coverage-query)

The asset index starts from a manifest id and reports the exact role, public API surface, source images, docs, and screenshots that keep that GLTF from being a passive file reference:

```ts
import {
  describeKayKitGuideAssetCoverage,
  listKayKitGuideAssetCoverages,
} from 'declarative-hex-worlds/catalog';


const roadM = describeKayKitGuideAssetCoverage('hex_road_M');
const allAssetCoverage = listKayKitGuideAssetCoverages();
```

## Page-Level Usage Query

[Section titled “Page-Level Usage Query”](#page-level-usage-query)

The usage index preserves repeated page-level asset occurrences for contact sheets, renderer tests, and audit tools that need the exact FREE/EXTRA guide scenario workload instead of only unique coverage rows:

```ts
import {
  listKayKitGuideScenarioAssetRenderGroups,
  listKayKitGuideScenarioAssetRenderRequests,
  listKayKitGuideScenarioAssetUsages,
  listKayKitGuideScenarioAssetUsagesForScenario,
} from 'declarative-hex-worlds/catalog';


const freeGuideAssets = listKayKitGuideScenarioAssetUsages({ minimumEdition: "free" });
const stableWorkshopUnits = listKayKitGuideScenarioAssetUsages({ pages: [16, 17, 18] });
const freeRenderQueue = listKayKitGuideScenarioAssetRenderRequests({
  minimumEdition: "free",
  assetBaseUrl: "/assets/free",
});
const groupedRenderQueue = listKayKitGuideScenarioAssetRenderGroups({ pages: [16, 17, 18] });
const page14Units = listKayKitGuideScenarioAssetUsagesForScenario('page-14-units');
```

## Role Coverage Index

[Section titled “Role Coverage Index”](#role-coverage-index)

The role index starts from a gameplay use case and reports every guide page, asset id, public API, doc, and screenshot that exercises that role:

```ts
import {
  describeKayKitGuideRoleCoverage,
  listKayKitGuideRoleCoverages,
} from 'declarative-hex-worlds/catalog';


const props = describeKayKitGuideRoleCoverage('prop');
const allRoleCoverage = listKayKitGuideRoleCoverages();
```

### Role - `base-tile`

[Section titled “Role - base-tile”](#role---base-tile)

* Pages: 07, 08, 09, 10
* Asset coverage: 4 unique, 4 FREE, 0 EXTRA, 8 occurrences
* Public API treatment: `GameboardBuilder.addElevationRamp`, `GameboardBuilder.addMountainStack`, `GameboardBuilder.setTerrain`, `GameboardBuilder.setTileAsset`, `createGameboardPlanFromRecipe`, `createGameboardPlanFromTiles`
* Scenarios: `page-07-water-usage`, `page-08-taller-hex-tiles`, `page-09-world-design-example`, `page-10-floating-islands`

### Role - `coast-tile`

[Section titled “Role - coast-tile”](#role---coast-tile)

* Pages: 07, 15
* Asset coverage: 10 unique, 10 FREE, 0 EXTRA, 20 occurrences
* Public API treatment: `GameboardBuilder.addHarbor`, `GameboardBuilder.setCoastEdges`, `listCoastGuidePermutations`, `selectCoastVariant`, `selectCoastVariantByLabel`
* Scenarios: `page-07-water-usage`, `page-15-shipyard-harbors`

### Role - `colored-unit-part`

[Section titled “Role - colored-unit-part”](#role---colored-unit-part)

* Pages: 14, 16, 17, 18
* Asset coverage: 112 unique, 0 FREE, 112 EXTRA, 448 occurrences
* Public API treatment: `GameboardBuilder.addUnit`, `GameboardBuilder.addUnitPreset`, `coloredUnitAssetId`, `spawnGameboardActor`
* Scenarios: `page-14-units`, `page-16-stables-and-horses`, `page-17-workshop-and-siege`, `page-18-unit-combinations`

### Role - `faction-building`

[Section titled “Role - faction-building”](#role---faction-building)

* Pages: 02, 15, 16, 17
* Asset coverage: 108 unique, 72 FREE, 36 EXTRA, 132 occurrences
* Public API treatment: `GameboardBuilder.addFactionBuilding`, `GameboardBuilder.addHarbor`, `GameboardBuilder.addSettlement`, `factionBuildingAssetId`
* Scenarios: `page-02-buildings-props-and-factions`, `page-15-shipyard-harbors`, `page-16-stables-and-horses`, `page-17-workshop-and-siege`

### Role - `nature-decoration`

[Section titled “Role - nature-decoration”](#role---nature-decoration)

* Pages: 05, 06, 09, 10
* Asset coverage: 42 unique, 42 FREE, 0 EXTRA, 168 occurrences
* Public API treatment: `GameboardBuilder.addForest`, `GameboardBuilder.addHill`, `GameboardBuilder.addMountainStack`, `GameboardBuilder.addNature`, `GameboardBuilder.scatterDecorations`, `createGameboardLayoutFillRuleFromPiece`
* Scenarios: `page-05-nature-contents`, `page-06-nature-usage`, `page-09-world-design-example`, `page-10-floating-islands`

### Role - `neutral-structure`

[Section titled “Role - neutral-structure”](#role---neutral-structure)

* Pages: 02, 07, 09, 16, 17
* Asset coverage: 21 unique, 21 FREE, 0 EXTRA, 55 occurrences
* Public API treatment: `GameboardBuilder.addBridge`, `GameboardBuilder.addConstructionSite`, `GameboardBuilder.addFortification`, `GameboardBuilder.addNeutralStructure`, `GameboardBuilder.addSiegeProjectile`, `createGameboardPlanFromRecipe`
* Scenarios: `page-02-buildings-props-and-factions`, `page-07-water-usage`, `page-09-world-design-example`, `page-16-stables-and-horses`, `page-17-workshop-and-siege`

### Role - `neutral-unit-part`

[Section titled “Role - neutral-unit-part”](#role---neutral-unit-part)

* Pages: 14, 16, 17, 18
* Asset coverage: 25 unique, 0 FREE, 25 EXTRA, 100 occurrences
* Public API treatment: `GameboardBuilder.addUnit`, `GameboardBuilder.addUnitPreset`, `neutralUnitAssetId`, `spawnGameboardActor`
* Scenarios: `page-14-units`, `page-16-stables-and-horses`, `page-17-workshop-and-siege`, `page-18-unit-combinations`

### Role - `prop`

[Section titled “Role - prop”](#role---prop)

* Pages: 02, 05, 15, 16, 17
* Asset coverage: 35 unique, 26 FREE, 9 EXTRA, 82 occurrences
* Public API treatment: `GameboardBuilder.addFlag`, `GameboardBuilder.addHarbor`, `GameboardBuilder.addProp`, `GameboardBuilder.addPropCluster`, `createGameboardLayoutFillRuleFromPiece`, `flagAssetId`, `listPropClusterAssets`
* Scenarios: `page-02-buildings-props-and-factions`, `page-05-nature-contents`, `page-15-shipyard-harbors`, `page-16-stables-and-horses`, `page-17-workshop-and-siege`

### Role - `river-tile`

[Section titled “Role - river-tile”](#role---river-tile)

* Pages: 04, 07
* Asset coverage: 30 unique, 30 FREE, 0 EXTRA, 60 occurrences
* Public API treatment: `GameboardBuilder.addRiverPath`, `listRiverCrossingGuidePermutations`, `listRiverCurvyGuidePermutations`, `listRiverGuidePermutations`, `selectRiverCrossingVariant`, `selectRiverVariant`, `selectRiverVariantByLabel`
* Scenarios: `page-04-river-variations`, `page-07-water-usage`

### Role - `road-tile`

[Section titled “Role - road-tile”](#role---road-tile)

* Pages: 03, 09
* Asset coverage: 15 unique, 15 FREE, 0 EXTRA, 30 occurrences
* Public API treatment: `GameboardBuilder.addRoadPath`, `listRoadGuidePermutations`, `selectRoadVariant`, `selectRoadVariantByLabel`
* Scenarios: `page-03-road-variations`, `page-09-world-design-example`

### Role - `support-tile`

[Section titled “Role - support-tile”](#role---support-tile)

* Pages: 08, 10
* Asset coverage: 1 unique, 1 FREE, 0 EXTRA, 2 occurrences
* Public API treatment: `GameboardBuilder.addMountainStack`, `GameboardBuilder.setTileAsset`, `createGameboardPlanFromRecipe`
* Scenarios: `page-08-taller-hex-tiles`, `page-10-floating-islands`

### Role - `transition-tile`

[Section titled “Role - transition-tile”](#role---transition-tile)

* Pages: 11, 12, 13
* Asset coverage: 1 unique, 0 FREE, 1 EXTRA, 3 occurrences
* Public API treatment: `GameboardBuilder.addTransition`, `createGameboardPlanFromRecipe`, `validateGameboardRecipe`
* Scenarios: `page-11-biomes`, `page-12-alternate-textures`, `page-13-transition-tiles`

## Public API Inversion

[Section titled “Public API Inversion”](#public-api-inversion)

The page matrix flows from guide page to public API. The inverse query starts from an API surface and reports every guide page, asset id, role, doc, and screenshot that exercises it:

```ts
import {
  describeKayKitGuidePublicApiCoverage,
  listKayKitGuidePublicApiCoverages,
} from 'declarative-hex-worlds/catalog';


const harbor = describeKayKitGuidePublicApiCoverage('GameboardBuilder.addHarbor');
const allApiCoverage = listKayKitGuidePublicApiCoverages();
```

For example, `GameboardBuilder.addHarbor` maps to pages 02, 05, 07, and 15, covering coast tiles, faction buildings, and props across FREE and EXTRA source material. `GameboardBuilder.addBridge` maps to pages 02, 07, and 09, covering the FREE bridge structures used by road and water crossings. `GameboardBuilder.addElevationRamp` maps to pages 08 and 10, covering the FREE sloped grass tiles used by vertical terrain transitions. `GameboardBuilder.addFortification`, `GameboardBuilder.addConstructionSite`, and `GameboardBuilder.addSiegeProjectile` cover the remaining FREE neutral wall, fence, construction, ruin, and projectile structures as authored gameplay intent instead of only raw neutral placements. `GameboardBuilder.addPropCluster` maps non-flag props to camps, resource caches, worksites, training yards, stable yards, and harbor support dressing with density, single-tile stacking, adjacent spread, and local EXTRA opt-in. `GameboardBuilder.addUnitPreset` maps to pages 14 through 18 and is EXTRA-only because the unit assembly pieces are local-ingest assets.

# KayKit Pack Upstream Layout

> Authoritative reference for the on-disk shape of the KayKit Medieval Hexagon Pack as bootstrapped by `declarative-hex-worlds`.

`declarative-hex-worlds` does not bundle KayKit asset binaries. The CLI `bootstrap` subcommand (and the equivalent `bootstrapKayKitAssets` programmatic API) mirrors the upstream KayKit pack tree into the consumer’s asset root at install time. This page is the authoritative description of the upstream layout the bootstrap step understands.

## Editions

[Section titled “Editions”](#editions)

Two editions are supported:

| Edition | License            | Source                                                                                                               |
| ------- | ------------------ | -------------------------------------------------------------------------------------------------------------------- |
| `free`  | CC0-1.0            | [KayKit-Medieval-Hexagon-Pack-1.0](https://github.com/KayKit-Game-Assets/KayKit-Medieval-Hexagon-Pack-1.0) on GitHub |
| `extra` | CC0-1.0 (purchase) | [`kaylousberg.itch.io`](https://kaylousberg.itch.io) — supplied via `--source zip`                                   |

## FREE edition layout

[Section titled “FREE edition layout”](#free-edition-layout)

Pack folder: `KayKit_Medieval_Hexagon_Pack_1.0_FREE/`

```text
KayKit_Medieval_Hexagon_Pack_1.0_FREE/
├── Assets/
│   ├── gltf/         # mirrored by bootstrap
│   │   ├── buildings/{blue,green,red,yellow,neutral}/
│   │   ├── decoration/{nature,props}/
│   │   └── tiles/{base,coast,rivers,roads}/
│   ├── fbx/          # ignored unless --include-source-formats
│   ├── fbx(unity)/   # ignored unless --include-source-formats
│   └── obj/          # ignored unless --include-source-formats
├── Textures/
│   └── hexagons_medieval.png
├── Samples/
│   ├── sample1.jpg
│   └── sample2.jpg
├── License.txt
├── Medieval_Hexagon_UserGuide_v1.pdf
├── contents_buildings.jpg
├── contents_nature.jpg
└── contents_tiles.jpg
```

* **GLTF count:** 221 (one `.bin` companion each).
* **Categories:** `buildings`, `decoration`, `tiles`.
* **Texture sets:** `default` only.

## EXTRA edition layout

[Section titled “EXTRA edition layout”](#extra-edition-layout)

Pack folder: `KayKit_Medieval_Hexagon_Pack_1.0_EXTRA/`

```text
KayKit_Medieval_Hexagon_Pack_1.0_EXTRA/
├── Assets/
│   ├── gltf/
│   │   ├── buildings/{blue,green,red,yellow,neutral}/
│   │   ├── decoration/{nature,props}/
│   │   ├── tiles/{base,coast,rivers,roads}/
│   │   └── units/{blue,green,red,yellow}/    # EXTRA-only category
│   ├── fbx/, fbx(unity)/, obj/               # ignored unless --include-source-formats
├── Textures/
│   ├── hexagons_medieval.png
│   ├── hexagons_medieval_Fall.png            # EXTRA-only seasonal texture
│   ├── hexagons_medieval_Summer.png          # EXTRA-only
│   └── hexagons_medieval_Winter.png          # EXTRA-only
├── License.txt
├── Medieval_Hexagon_UserGuide_v1.pdf
├── contents_buildings.jpg
├── contents_nature.jpg
├── contents_tiles.jpg
├── contents_textures.jpg                     # EXTRA-only marker
└── contents_units.jpg                        # EXTRA-only marker
```

* **GLTF count:** 404 (one `.bin` companion each).
* **Categories:** `buildings`, `decoration`, `tiles`, `units`.
* **Texture sets:** `default`, `fall`, `summer`, `winter`.

## Bootstrap target layout

[Section titled “Bootstrap target layout”](#bootstrap-target-layout)

Both editions are mirrored under the same path on the consumer:

```text
<consumer-out>/addons/kaykit_medieval_hexagon_pack/
├── Assets/gltf/...        # mirror of the upstream gltf tree
└── .bootstrap.json        # integrity sidecar
```

`<consumer-out>` defaults to `public/assets/models/` (Vite / Next.js style), falling back to `assets/models/` and then the current working directory. It can be overridden with `--out` on the CLI or `BootstrapKayKitAssetsOptions.out` in the programmatic API.

## Edition detection

[Section titled “Edition detection”](#edition-detection)

The bootstrap step (and the programmatic [`detectKayKitLayout`](https://jsr.io/declarative-hex-worlds) helper) identifies an edition by checking marker files plus the presence of the `units/` directory:

| Marker / signal                     | FREE | EXTRA |
| ----------------------------------- | ---- | ----- |
| `License.txt`                       | yes  | yes   |
| `Medieval_Hexagon_UserGuide_v1.pdf` | yes  | yes   |
| `contents_buildings.jpg`            | yes  | yes   |
| `contents_nature.jpg`               | yes  | yes   |
| `contents_tiles.jpg`                | yes  | yes   |
| `contents_units.jpg`                | no   | yes   |
| `contents_textures.jpg`             | no   | yes   |
| `Assets/gltf/units/`                | no   | yes   |

EXTRA is tested first because its marker set is a superset of FREE’s.

## Programmatic surface

[Section titled “Programmatic surface”](#programmatic-surface)

```ts
import {
  KAYKIT_MEDIEVAL_FREE_LAYOUT,
  KAYKIT_MEDIEVAL_EXTRA_LAYOUT,
  detectKayKitLayout,
  kayKitLayoutForEdition,
  expectedTexturePaths,
  type KayKitUpstreamLayout,
} from 'declarative-hex-worlds/bootstrap/upstream-layout';
```

Use these to:

* Pre-flight check an extracted pack folder (`detectKayKitLayout(rootPath)`).
* Drive consumer-side validation pipelines that need the published asset counts (`KAYKIT_MEDIEVAL_FREE_LAYOUT.expectedGltfCount`).
* List the texture filenames an edition should have shipped (`expectedTexturePaths(rootPath, layout)`).

# Live demos

> In-browser boards rendered through the declarative-hex-worlds renderer bindings — the docs run the library, they don't just describe it.

The signals-and-bindings architecture lets one world drive any renderer. These demos render the **same** reference example game — a deterministic world compiled from a JSON scenario into a live Koota runtime — through different renderer bindings, live in your browser.

## Available demos

[Section titled “Available demos”](#available-demos)

* **[Canvas-2D binding →](/demo/canvas2d/)** — the game drawn as 2D sprites through `declarative-hex-worlds/canvas2d`. Zero renderer dependency and no downloaded art (the sprite sheet is generated procedurally), so it runs anywhere a 2D canvas exists.

## How it works

[Section titled “How it works”](#how-it-works)

The core (`declarative-hex-worlds`) is renderer-free: it emits reactive Koota-trait *signals* — each placement’s position, asset, and dimension. A renderer *binding* subscribes to those signals and reconciles its own scene:

* `declarative-hex-worlds/canvas2d` turns each `{ dimension: '2d' }` placement into a sprite blit on a `CanvasRenderingContext2D`.
* `declarative-hex-worlds/three` takes the *same* signals and reconciles a Three.js scene for `{ dimension: '3d' }` GLTF models.

Both consume the identical shared game (`@declarative-hex-worlds/examples`), proving the render seam is genuinely substrate-agnostic. A Pixi binding would be the same shape with `PIXI.Sprite` in place of `drawImage`.

# Migration Guide

> How to upgrade between declarative-hex-worlds versions and migrate from the pre-release package name.

## From the pre-release scoped package (`@jbcom/medieval-hexagon-gameboard`)

[Section titled “From the pre-release scoped package (@jbcom/medieval-hexagon-gameboard)”](#from-the-pre-release-scoped-package-jbcommedieval-hexagon-gameboard)

Before the 1.0.0 release, the library was distributed under the internal scoped name `@jbcom/medieval-hexagon-gameboard`. The public 1.0.0 release renamed it to the unscoped `declarative-hex-worlds`.

### Step 1 — Update your `package.json` dependency

[Section titled “Step 1 — Update your package.json dependency”](#step-1--update-your-packagejson-dependency)

```diff
"@jbcom/medieval-hexagon-gameboard": "^0.x.x"
"declarative-hex-worlds": "^1.0.0"
```

### Step 2 — Update all import statements

[Section titled “Step 2 — Update all import statements”](#step-2--update-all-import-statements)

```diff
import { createGameboard } from '@jbcom/medieval-hexagon-gameboard';
import { createGameboard } from 'declarative-hex-worlds';
```

Subpath imports follow the same pattern:

```diff
import { hexKey } from '@jbcom/medieval-hexagon-gameboard/coordinates';
import { hexKey } from 'declarative-hex-worlds/coordinates';
```

### Step 3 — Update the CLI binary name

[Section titled “Step 3 — Update the CLI binary name”](#step-3--update-the-cli-binary-name)

The CLI binary was also renamed:

```diff
npx @jbcom/medieval-hexagon-gameboard <command>
npx declarative-hex-worlds <command>
```

Or via pnpm exec:

```diff
pnpm exec medieval-hexagon-gameboard <command>
pnpm exec declarative-hex-worlds <command>
```

### Step 4 — Update environment variables

[Section titled “Step 4 — Update environment variables”](#step-4--update-environment-variables)

The output jail environment variable was renamed:

```diff
MEDIEVAL_HEXAGON_OUT_ROOT=/path/to/output
HEX_WORLDS_OUT_ROOT=/path/to/output
```

### What did NOT change

[Section titled “What did NOT change”](#what-did-not-change)

* The published API surface — all exported functions, types, and constants are identical.
* The subpath structure — all `/coordinates`, `/gameboard`, `/scenario`, etc. subpaths are preserved.
* The asset format — existing recipe JSON files, scenario files, and manifest files are fully compatible.

## From 1.0.x to 1.1.x

[Section titled “From 1.0.x to 1.1.x”](#from-10x-to-11x)

No breaking changes. Patch releases only.

## API versioning policy

[Section titled “API versioning policy”](#api-versioning-policy)

Starting from 1.0.0, this package follows [Semantic Versioning](https://semver.org):

* **Patch** (`1.0.x`): bug fixes, documentation, internal optimizations.
* **Minor** (`1.x.0`): new exports, new subpaths, additive API changes.
* **Major** (`x.0.0`): breaking changes to existing exports, removed subpaths, renamed types.

Breaking changes will always be documented here with a concrete migration path before they ship.

# Public API tier table

> Three-tier export taxonomy (umbrella / domain subpath / internal).

`declarative-hex-worlds` publishes one umbrella entry plus a wide set of subpath exports. **Every subpath stays supported through 1.0** — this is an asset-bundled library where mod authors, custom-renderer builders, and data-inspection tooling all have legitimate reasons to reach internals.

What changes between tiers is the **stability contract**, not the availability. Pick the tier that matches your tolerance for breakage; the tooling and TSDoc tags tell you which tier a symbol belongs to.

## Tier 1 — Stable

[Section titled “Tier 1 — Stable”](#tier-1--stable)

Semver-strict. Breaking changes only on major versions, always with a migration guide.

| Subpath             | Purpose                                                                                           |
| ------------------- | ------------------------------------------------------------------------------------------------- |
| `.` (umbrella)      | Default entry. Re-exports the consumer-facing surface from every tier-1 sub-package.              |
| `./react`           | React bindings. First-class (NOT peer-gated). Hooks, providers, components.                       |
| `./three`           | Three.js bindings. First-class (NOT peer-gated). Loaders, disposers, scene helpers.               |
| `./cli`             | CLI entry (also installed as the `declarative-hex-worlds` bin).                                   |
| `./manifest/schema` | `MedievalHexagonManifest` shape + validators.                                                     |
| `./manifest/free`   | Pre-baked FREE-edition manifest metadata.                                                         |
| `./scenario`        | `GameboardScenario`, blueprint/recipe/catalog/registry.                                           |
| `./blueprint`       | `GameboardBlueprintOptions` and procedural board generation.                                      |
| `./gameboard`       | Board lifecycle, occupancy, navigation.                                                           |
| `./recipe`          | Recipe DSL.                                                                                       |
| `./coverage`        | Release-readiness coverage ledger surface for build/review tooling, not runtime ECS adapter glue. |
| `./compatibility`   | Manifest/version compatibility helpers.                                                           |
| `./errors`          | `GameboardError` + typed subclasses (Epic D2).                                                    |
| `./traits`          | Single trait umbrella (all `trait()` declarations).                                               |
| `./types`           | Shared primitive types + branded IDs (`HexKey`, `ActorId`, etc.).                                 |
| `./examples/*.json` | Bundled example scenario JSON.                                                                    |

TSDoc tag: `@public`.

## Branded ID migration status

[Section titled “Branded ID migration status”](#branded-id-migration-status)

The `./types` subpath exports branded ID aliases and `brand*` helpers, but branded IDs are **NOT yet enforced** across the runtime. Public JSON, manifest, CLI, and ECS-facing shapes still use plain strings unless a domain row below states that enforcement has landed. Treat the aliases as opt-in compile-time helpers until the relevant domain moves to `enforced`.

| Domain(s)                                                                             | Brands tracked                                                                                                              | Current status                                                                                     |
| ------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| `./types`                                                                             | `HexKey`, `ActorId`, `TileId`, `PieceId`, `PlacementId`, `ScenarioId`, `QuestId`, `ObjectiveId`, `PatrolRouteId`, `AssetId` | Registry exported; `brand*` helpers are stable and available to consumers.                         |
| `./coordinates`, `./grid`, `./layout`, `./gameboard`                                  | `HexKey`, `TileId`                                                                                                          | Not yet enforced; public APIs still accept coordinate objects and plain string IDs.                |
| `./scenario`, `./recipe`, `./blueprint`, `./simulation`, `./pieces`                   | `ScenarioId`, `PieceId`, `PlacementId`, `TileId`, `AssetId`                                                                 | Not yet enforced; scenario JSON and generated plans keep wire-compatible string fields.            |
| `./actors`, `./movement`, `./patrol`, `./quests`                                      | `ActorId`, `PatrolRouteId`, `QuestId`, `ObjectiveId`                                                                        | Not yet enforced; ECS traits, commands, and query helpers still expose string-compatible IDs.      |
| `./manifest/schema`, `./manifest/free`, `./ingest`, `./runtime`, `./react`, `./three` | `AssetId`                                                                                                                   | Not yet enforced; asset IDs remain manifest and URL-facing strings.                                |
| `./cli`, `./interop`, `./compatibility`, `./coverage`                                 | Pass-through IDs only                                                                                                       | Not yet enforced; these surfaces preserve external wire formats and report existing domain values. |

## Tier 2 — Supported-for-extension

[Section titled “Tier 2 — Supported-for-extension”](#tier-2--supported-for-extension)

Semver-strict for what’s documented, but the surface contract is smaller than tier 1. Mod authors and custom-renderer consumers can depend on these; breaking changes still require a major + migration guide but the “what’s breaking” frame may be narrower (a specific function signature changing rather than the whole module shape).

| Subpath         | Purpose                                                        |
| --------------- | -------------------------------------------------------------- |
| `./koota`       | World bootstrap, trait sets, query patterns.                   |
| `./runtime`     | High-level runtime composition.                                |
| `./actors`      | Actor surface + queries.                                       |
| `./movement`    | Movement-agent surface.                                        |
| `./patrol`      | Patrol-route surface.                                          |
| `./quests`      | Quest surface.                                                 |
| `./pieces`      | Piece declarations + placement helpers.                        |
| `./projection`  | World-space placement projection.                              |
| `./layout`      | Seeded board layout generation.                                |
| `./grid`        | Honeycomb-grid wrappers + hex algebra.                         |
| `./coordinates` | Hex coordinate algebra (umbrella over grid/projection/layout). |
| `./validation`  | Plan-level validators.                                         |
| `./rules`       | Rule definitions + evaluation.                                 |

TSDoc tag: `@public` (no distinct tag — tier 2 is documented here in the table, not on every symbol).

## Tier 3 — Internal-but-exposed

[Section titled “Tier 3 — Internal-but-exposed”](#tier-3--internal-but-exposed)

Semver-**permissive**: minor versions may change these surfaces in non-trivial ways. Consumers who pin tier-3 imports accept this tradeoff. Useful for very-deep modding, debugging, and tools that need to inspect or hook the implementation.

| Subpath         | Purpose                                                                                                                 |
| --------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `./commands`    | Internal command-factory plumbing.                                                                                      |
| `./selectors`   | Per-render shape pickers used by React/Three bindings.                                                                  |
| `./systems`     | Tickable system functions.                                                                                              |
| `./world-rules` | Runtime rule-evaluation system.                                                                                         |
| `./rule-types`  | Rule typed shapes (re-exported from `./rules` — prefer that).                                                           |
| `./interop`     | Runtime ECS adapter glue and schema migrations; release-readiness coverage is the separate stable `./coverage` surface. |
| `./ingest`      | Source-tree walker + manifest emission (precursor to bootstrap).                                                        |
| `./registry`    | Tile/piece registries (re-exported from `./scenario`).                                                                  |
| `./catalog`     | KayKit asset catalog (re-exported from `./scenario`).                                                                   |

TSDoc tag: `@internal` (still exported, still typed, still tested — just flagged so consumers see the support tier inline).

## Why the three tiers?

[Section titled “Why the three tiers?”](#why-the-three-tiers)

Phase 1’s architecture review (F1) noted that the 37+ subpath exports permanently pin every internal module as a semver surface point. The original recommendation was to demote \~10 subpaths and force everything through the umbrella.

Per PRD §4 Epic D1 (re-scoped), that was rejected: this library bundles the FREE KayKit pack so consumers get a working game out-of-box, and the “out-of-box” promise extends to consumers who want to reach internals for legitimate reasons (custom renderers, modding, data inspection). The right tradeoff is **documented tiering**, not gated demotion.

If a tier-3 surface stabilizes (a custom-renderer mod has been depending on `./selectors` for two minor versions without breakage), it can be promoted to tier 2 via a CHANGELOG note. The reverse (demoting a tier-1 surface) is a major-version event.

## Trait identity invariant

[Section titled “Trait identity invariant”](#trait-identity-invariant)

Regardless of tier, every `trait()` declaration is exported from **exactly one module**. `tsup`’s `splitting: true` keeps shared chunks stable so that two consumers importing `GameboardActor` from different subpaths (e.g. one via `./actors`, another via the umbrella) get the SAME trait identity — which is what koota’s `useQuery` reference-equality lookups depend on.

Don’t try to “optimize” by re-declaring a trait somewhere else. Don’t fork the trait file into a “local” copy. The trait-identity test (Epic E4, pending) pins this.

# Recipes, scenarios, and simulation

> The recipe → blueprint → scenario → simulation pipeline.

Recipes describe board intent. Scenarios add game content. Simulation scripts exercise the same public API a game loop would use.

## Recipes

[Section titled “Recipes”](#recipes)

A recipe is the smallest useful serialized authoring format. It can contain:

* a board shape and seed.
* explicit tile or placement steps.
* layout archetypes local to the recipe.
* generated `layoutFills` for built-in archetypes.
* generated `pieceDeclarations` and `pieceFills` for custom packs.
* manifest validation requirements.

Use recipes when a board needs to be saved, generated by tools, checked into a game repository, or reviewed in documentation.

```ts
import {
  createGameboardPlanFromRecipe,
  inspectGameboardRecipe,
} from 'declarative-hex-worlds/recipe';
import { freeManifest } from 'declarative-hex-worlds/manifest/free';


const preflight = inspectGameboardRecipe(recipeJson, {
  plan: { assetCatalog: freeManifest },
});


const recipeErrors = preflight.violations.filter((issue) => issue.severity === 'error');
if (recipeErrors.length > 0) {
  throw new Error(recipeErrors.map((issue) => issue.message).join('\n'));
}


const plan = createGameboardPlanFromRecipe(recipeJson);
```

Recipe generation should be deterministic. Use one seed for board terrain and a separate seed namespace for layout fills, piece fills, spawn groups, or patrols when a game needs stable diffs.

## Layout And Piece Fills

[Section titled “Layout And Piece Fills”](#layout-and-piece-fills)

Layout fills are the core random-board primitive. They combine a placement role, candidate-site criteria, density or count, and deterministic scoring.

Common cases:

* trees use scatter or tree archetypes, often with `fill`, `maxCount`, `maxPerTile`, and a shared slot group.
* harbors use coast tiles adjacent to water.
* landmarks and towers use larger footprints and occupancy reservations.
* units use spawn-like criteria and usually remain low-density.
* loose props can allow occupied tiles if they use a non-blocking slot group.

Piece fills are the custom-pack version of layout fills. They select reusable piece declarations by id, asset id, role, source, tag, or local-only state, then expand the selection into deterministic layout rules.

Run analysis before committing generated placements into a plan or runtime:

```ts
import { analyzeGameboardLayoutFill } from 'declarative-hex-worlds/layout';
import { inspectSeededGameboardPieceFills } from 'declarative-hex-worlds/rules';


const layoutReport = analyzeGameboardLayoutFill(plan, layoutFill);
const pieceReport = inspectSeededGameboardPieceFills(plan, registry, pieceFills, {
  seed: 'campaign-01:custom-pieces',
});
```

Warnings are useful, not cosmetic. A low candidate count, clamped fill count, or large footprint rejection usually means the authored board cannot support the requested density.

`createGameboardLayoutPlacements` — the single-placement path used for structures, landmarks, and other one-off pieces — returns an empty array with no warnings when its resolved criteria match zero sites. This is easy to misread as “the board is full” when the real cause is an archetype-inherited criteria field the caller never set (for example, the `landmark` archetype defaults `edgePadding` to `1`, which silently excludes edge tiles a caller’s override criteria did not think to re-enable). Pass `onDiagnostics` to see the fully resolved criteria and a rejection histogram whenever the selected count falls short of the requested count:

```ts
import { createGameboardLayoutPlacements } from 'declarative-hex-worlds/layout';


const placements = createGameboardLayoutPlacements(plan, {
  archetype: 'landmark',
  count: 1,
  assetId: 'obelisk',
  criteria: { terrain: 'grass' }, // edgePadding: 1 is still inherited from the archetype
  onDiagnostics: (diagnostics) => {
    console.warn(
      `landmark placement short by ${diagnostics.requestedCount - diagnostics.selectedCount}`,
      diagnostics.resolvedCriteria, // shows the inherited edgePadding
      diagnostics.rejectionCounts // names which filter emptied the candidate set
    );
  },
});
```

`onDiagnostics` is only invoked when `selectedCount` is less than the requested `count`; omitting it is a no-op with identical placement output.

## Scenarios

[Section titled “Scenarios”](#scenarios)

A scenario combines a recipe with gameplay objects:

* named spawn groups.
* patrol route plans.
* actors, including players, NPCs, enemies, props, blockers, and interactives.
* movement agents and movement profiles.
* patrol agents.
* quests.
* renderer source URL maps for local custom pieces.

Scenarios are the preferred test fixture for integration and browser coverage because they force consumers to use the package the way a game does.

```ts
import { createGameboardRuntimeFromScenario } from 'declarative-hex-worlds/runtime';
import { validateGameboardScenario } from 'declarative-hex-worlds/scenario';


const validation = validateGameboardScenario(scenarioJson, {
  plan: { assetCatalog: manifest },
});


const scenarioErrors = validation.filter((issue) => issue.severity === 'error');
if (scenarioErrors.length > 0) {
  throw new Error(scenarioErrors.map((issue) => issue.message).join('\n'));
}


const runtime = createGameboardRuntimeFromScenario(scenarioJson);
```

Scenario validation should fail duplicate ids, unresolved spawn groups, duplicate spawn-location claims, missing patrol routes, broken actor references, broken quest references, missing manifest assets, and invalid runtime placement requests.

## Simulation Scripts

[Section titled “Simulation Scripts”](#simulation-scripts)

Simulation scripts are deterministic headless game-loop tests. They can run:

* movement commands.
* `run-systems` ticks for patrols, movement, commands, actor targets, and quests.
* command previews and command execution.
* actor-target inspections and chosen-target dispatch.
* actor spawn, update, and removal mutations.
* placement spawn, update, move, and removal mutations.
* expectation checks against actors, quests, movement, events, commands, and final placement records.

```ts
import {
  runGameboardScenarioSimulationScript,
  validateGameboardScenarioSimulationScript,
} from 'declarative-hex-worlds/simulation';


const scriptValidation = validateGameboardScenarioSimulationScript(scriptJson, {
  scenario: scenarioJson,
});


const simulationErrors = scriptValidation.filter((issue) => issue.severity === 'error');
if (simulationErrors.length > 0) {
  throw new Error(simulationErrors.map((issue) => issue.message).join('\n'));
}


const result = runGameboardScenarioSimulationScript(scenarioJson, scriptJson);
```

The `SimpleRPG` fixtures in the package are the canonical acceptance shape. They spawn a player, traverse a fixed board, classify props and enemies through public actor APIs, advance quests, and exercise seeded content through the same scenario and simulation layer. The packaged usage example also exposes `summarizeSimpleRpgGuidePublicApiExercises()`, which joins every current guide-facing public API to SimpleRPG evidence so app smoke tests can fail on missing or stale guide/API representation. Evidence modes are memberships, not exclusive buckets, so one API can be executable smoke and also prove seeded generation, blueprint compilation, manifest packaging, compatibility adapters, or visual coverage. Its executable helper smoke directly invokes 40 guide-facing helper APIs and checks the 404 KayKit public treatment records plus all 19 decomposed guide pages, so catalog coverage is exercised through package imports as well as the generated ledger.

## CLI Flow

[Section titled “CLI Flow”](#cli-flow)

Use the CLI to preflight serialized content outside a test runner:

```bash
declarative-hex-worlds validate-recipe \
  --recipe docs/examples/generated-piece-scenario.recipe.json \
  --outPlan /tmp/generated-piece-scenario.plan.json


declarative-hex-worlds validate-scenario \
  --scenario <your-scenario.json> \
  --manifest assets/free/manifest.json \
  --outPlan /tmp/simple-rpg-plan.json


declarative-hex-worlds validate-simulation \
  --scenario <your-scenario.json> \
  --script <your-simulation-script.json> \
  --manifest assets/free/manifest.json


declarative-hex-worlds simulate-scenario \
  --scenario <your-scenario.json> \
  --script <your-simulation-script.json> \
  --manifest assets/free/manifest.json \
  --out /tmp/simple-rpg-simulation.json \
  --outInterop /tmp/simple-rpg-interop.json
```

For browser E2E, render the same scenarios rather than creating private renderer-only fixtures. That keeps screenshots tied to the public contract.

# Release readiness coverage

> Generated ledger of feature + asset coverage at release time.

This generated ledger combines the decomposed KayKit guide coverage, manifest coverage, public API treatment, visual artifacts, local reference packs, and package verification gates. Regenerate it with:

```bash
pnpm coverage:ledger
```

## Summary

[Section titled “Summary”](#summary)

* Status: passed
* Guide pages: 19/19
* Guide scenarios: 19
* Guide assets: 404 unique (221 FREE, 183 EXTRA), 1108 page-level occurrences
* Public API surfaces: 74
* Public roles: 12
* Visual artifacts: 70 available, 0 missing, 0 skipped
* Local references: 4 available, 0 missing, 0 skipped
* Release checks: 12 passed, 0 failed, 0 not run, 0 skipped
* SimpleRPG API evidence: 74/74 represented, 40 directly executed, 9 active mode(s)

## Manifest Coverage

[Section titled “Manifest Coverage”](#manifest-coverage)

* Manifest edition: free
* Manifest assets: 221
* FREE guide assets in manifest: 221/221
* FREE guide assets missing from manifest: 0
* EXTRA guide assets kept local-only: 183/183
* Manifest validation: 0 error(s), 0 warning(s)

## SimpleRPG Public API Evidence

[Section titled “SimpleRPG Public API Evidence”](#simplerpg-public-api-evidence)

* Guide-facing public APIs represented: 74/74
* Direct executable helper APIs: 40
* KayKit public treatment records asserted: 404
* Decomposed guide pages asserted: 19
* Missing public APIs: 0
* Stale evidence rows: 0

| Mode                  | API Count |
| --------------------- | --------- |
| fixed-gameplay        | 30        |
| seeded-generation     | 10        |
| packaged-scenario     | 1         |
| executable-smoke      | 40        |
| blueprint-recipe      | 4         |
| manifest-package      | 6         |
| compatibility-adapter | 2         |
| package-boundary      | 3         |
| visual-coverage       | 26        |

### SimpleRPG Exercise Matrix

[Section titled “SimpleRPG Exercise Matrix”](#simplerpg-exercise-matrix)

| Public API                               | Modes                                              | Pages                              | Assets | Evidence                                                                                         |
| ---------------------------------------- | -------------------------------------------------- | ---------------------------------- | ------ | ------------------------------------------------------------------------------------------------ |
| `analyzeHexTileRegistry`                 | executable-smoke                                   | 13                                 | 0      | Packaged SimpleRPG usage analyzes a runtime tile registry in its executable guide API smoke.     |
| `coloredUnitAssetId`                     | executable-smoke                                   | 14, 16, 17, 18                     | 112    | Packaged SimpleRPG usage resolves a colored unit asset id in executable smoke.                   |
| `createGameboardBuilder`                 | fixed-gameplay                                     | 9                                  | 0      | Fixed SimpleRPG board starts from the public fluent builder.                                     |
| `createGameboardLayoutArchetypeRegistry` | executable-smoke, seeded-generation                | 6                                  | 0      | Packaged SimpleRPG usage creates a layout archetype registry in executable smoke.                |
| `createGameboardLayoutFillRuleFromPiece` | executable-smoke, seeded-generation                | 2, 5, 6, 9, 10, 15, 16, 17         | 77     | Packaged SimpleRPG usage creates a piece-backed layout fill rule in executable smoke.            |
| `createGameboardPlanFromRecipe`          | executable-smoke                                   | 2, 7, 8, 9, 10, 11, 12, 13, 16, 17 | 25     | Packaged SimpleRPG usage compiles a recipe into a concrete plan in executable smoke.             |
| `createGameboardPlanFromTiles`           | executable-smoke                                   | 7, 9                               | 2      | Packaged SimpleRPG usage rebuilds a plan from explicit tiles in executable smoke.                |
| `createGameboardRuntimeFromScenario`     | packaged-scenario                                  | 9, 18                              | 0      | Packaged SimpleRPG usage creates a runtime facade directly from the scenario JSON.               |
| `createHexagonGameboardGrid`             | executable-smoke                                   | 10                                 | 0      | Packaged SimpleRPG usage creates a Honeycomb hexagon grid in executable smoke.                   |
| `createManifestBundle`                   | executable-smoke, manifest-package                 | 12                                 | 0      | Packaged SimpleRPG usage bundles the FREE manifest in executable smoke.                          |
| `createGameboardBlueprintPlan`           | executable-smoke, blueprint-recipe                 | 6, 10                              | 0      | Packaged SimpleRPG usage compiles a blueprint plan in executable smoke.                          |
| `createGameboardBlueprintRecipe`         | executable-smoke, blueprint-recipe                 | 5, 8, 11, 13                       | 0      | Packaged SimpleRPG usage compiles a blueprint recipe in executable smoke.                        |
| `createMedievalShowcaseBlueprintRecipe`  | executable-smoke, blueprint-recipe                 | 9, 13                              | 0      | Packaged SimpleRPG usage compiles the showcase blueprint recipe in executable smoke.             |
| `createSeededGameboardPlan`              | executable-smoke, seeded-generation                | 9                                  | 0      | Packaged SimpleRPG usage builds a seeded board in executable smoke.                              |
| `declareHexTile`                         | executable-smoke                                   | 13                                 | 0      | Packaged SimpleRPG usage declares a tile for registry analysis in executable smoke.              |
| `executeGameboardInteractionCommand`     | fixed-gameplay                                     | 17                                 | 0      | SimpleRPG quest execution moves, interacts, attacks, and removes enemies through commands.       |
| `externalAssetSpawnOptions`              | executable-smoke, compatibility-adapter            | 15                                 | 0      | Packaged SimpleRPG usage converts compatibility analysis into spawn options in executable smoke. |
| `factionBuildingAssetId`                 | executable-smoke                                   | 2, 15, 16, 17                      | 108    | Packaged SimpleRPG usage resolves a faction building asset id in executable smoke.               |
| `flagAssetId`                            | executable-smoke                                   | 2, 5                               | 4      | Packaged SimpleRPG usage resolves a faction flag asset id in executable smoke.                   |
| `freeManifest`                           | executable-smoke, manifest-package                 | 1                                  | 0      | Packaged SimpleRPG usage reads the FREE manifest in executable smoke.                            |
| `GameboardBuilder.addBridge`             | fixed-gameplay, visual-coverage                    | 2, 7, 9                            | 2      | Fixed SimpleRPG board places a bridge beside the harbor approach.                                |
| `GameboardBuilder.addConstructionSite`   | fixed-gameplay, visual-coverage                    | 2, 17                              | 7      | Fixed SimpleRPG board places a staged worksite off the golden path.                              |
| `GameboardBuilder.addElevationRamp`      | fixed-gameplay, visual-coverage                    | 8, 10                              | 2      | Fixed SimpleRPG board places a ramp against an elevated tile.                                    |
| `GameboardBuilder.addFactionBuilding`    | fixed-gameplay, visual-coverage                    | 2, 15, 16, 17                      | 108    | Fixed and packaged SimpleRPG boards place faction buildings.                                     |
| `GameboardBuilder.addFlag`               | fixed-gameplay, visual-coverage                    | 2, 5                               | 4      | Fixed SimpleRPG board places a faction flag and runtime actors use flag assets.                  |
| `GameboardBuilder.addForest`             | fixed-gameplay, seeded-generation, visual-coverage | 5, 6, 9, 10                        | 12     | Fixed and seeded SimpleRPG boards include forests and tree scatter.                              |
| `GameboardBuilder.addFortification`      | fixed-gameplay, visual-coverage                    | 2, 16, 17                          | 11     | Fixed SimpleRPG board places a town wall segment with enclosure metadata.                        |
| `GameboardBuilder.addHarbor`             | fixed-gameplay, seeded-generation, visual-coverage | 2, 5, 7, 15                        | 25     | Fixed and seeded SimpleRPG boards include a playable harbor/coast relationship.                  |
| `GameboardBuilder.addHill`               | fixed-gameplay, seeded-generation, visual-coverage | 5, 6, 9, 10                        | 9      | Fixed and seeded SimpleRPG boards include hill terrain and decorations.                          |
| `GameboardBuilder.addMountainStack`      | fixed-gameplay, seeded-generation, visual-coverage | 5, 6, 8, 9, 10                     | 12     | Fixed, seeded, and packaged SimpleRPG boards place stacked mountains.                            |
| `GameboardBuilder.addNature`             | fixed-gameplay, visual-coverage                    | 5, 6, 9, 10                        | 42     | Fixed SimpleRPG board places standalone nature assets.                                           |
| `GameboardBuilder.addNeutralStructure`   | fixed-gameplay, visual-coverage                    | 2, 7, 9, 16, 17                    | 21     | Fixed SimpleRPG board places a neutral grain building.                                           |
| `GameboardBuilder.addProp`               | fixed-gameplay, visual-coverage                    | 2, 5, 15, 16, 17                   | 35     | Fixed SimpleRPG quest uses a registered crate prop as a passable actor target.                   |
| `GameboardBuilder.addPropCluster`        | fixed-gameplay, visual-coverage                    | 2, 5, 15, 16, 17                   | 31     | Fixed SimpleRPG board places a resource-cache cluster.                                           |
| `GameboardBuilder.addRiverPath`          | fixed-gameplay, visual-coverage                    | 4, 7                               | 30     | Fixed SimpleRPG board routes a curvy waterless river through the quest road.                     |
| `GameboardBuilder.addRoadPath`           | fixed-gameplay, seeded-generation, visual-coverage | 3, 9                               | 15     | Fixed, seeded, and packaged SimpleRPG boards use roads for movement routes.                      |
| `GameboardBuilder.addSettlement`         | fixed-gameplay, visual-coverage                    | 2, 16, 17                          | 96     | Fixed SimpleRPG board places a settlement home through the settlement alias.                     |
| `GameboardBuilder.addSiegeProjectile`    | fixed-gameplay, visual-coverage                    | 2, 17                              | 1      | Fixed SimpleRPG board places a catapult projectile beside the town wall.                         |
| `GameboardBuilder.addTransition`         | fixed-gameplay, visual-coverage                    | 11, 12, 13                         | 1      | Fixed SimpleRPG board places a local-only texture transition and marks it EXTRA.                 |
| `GameboardBuilder.addUnit`               | fixed-gameplay, visual-coverage                    | 14, 16, 17, 18                     | 137    | Fixed SimpleRPG board places colored and neutral EXTRA unit parts.                               |
| `GameboardBuilder.addUnitPreset`         | fixed-gameplay, visual-coverage                    | 14, 15, 16, 17, 18                 | 137    | Fixed SimpleRPG board places a composed soldier preset.                                          |
| `GameboardBuilder.scatterDecorations`    | fixed-gameplay, seeded-generation, visual-coverage | 5, 6, 9, 10                        | 42     | Fixed and seeded SimpleRPG boards scatter decorations deterministically.                         |
| `GameboardBuilder.setCoastEdges`         | fixed-gameplay, visual-coverage                    | 7, 15                              | 10     | Fixed SimpleRPG board marks the water edge as coast before adding a harbor.                      |
| `GameboardBuilder.setElevation`          | fixed-gameplay, visual-coverage                    | 8, 10                              | 0      | Fixed SimpleRPG board raises a tile and then adds an elevation ramp.                             |
| `GameboardBuilder.setTerrain`            | fixed-gameplay, seeded-generation, visual-coverage | 7, 9                               | 2      | Fixed SimpleRPG board authors a full water row and seeded generation fills terrain.              |
| `GameboardBuilder.setTileAsset`          | fixed-gameplay, visual-coverage                    | 7, 8, 9, 10                        | 5      | Fixed and packaged SimpleRPG boards override authored tile assets and tags.                      |
| `inspectGameboardBlueprint`              | executable-smoke, blueprint-recipe                 | 6, 11                              | 0      | Packaged SimpleRPG usage inspects a blueprint in executable smoke.                               |
| `listCoastGuidePermutations`             | executable-smoke                                   | 7, 15                              | 10     | Packaged SimpleRPG usage lists coast guide permutations in executable smoke.                     |
| `listKayKitAssetPublicTreatments`        | executable-smoke                                   | 1                                  | 0      | Packaged SimpleRPG usage lists every KayKit asset public treatment in executable smoke.          |
| `listKayKitGuideScenarios`               | executable-smoke                                   | 1, 19                              | 0      | Packaged SimpleRPG usage lists every decomposed KayKit guide scenario in executable smoke.       |
| `listPropClusterAssets`                  | executable-smoke                                   | 2, 5, 15, 16, 17                   | 31     | Packaged SimpleRPG usage resolves prop-cluster assets in executable smoke.                       |
| `listRiverCrossingGuidePermutations`     | executable-smoke                                   | 4, 7                               | 4      | Packaged SimpleRPG usage lists river crossing permutations in executable smoke.                  |
| `listRiverCurvyGuidePermutations`        | executable-smoke                                   | 4, 7                               | 2      | Packaged SimpleRPG usage lists curvy river permutations in executable smoke.                     |
| `listRiverGuidePermutations`             | executable-smoke                                   | 4, 7                               | 24     | Packaged SimpleRPG usage lists river permutations in executable smoke.                           |
| `listRoadGuidePermutations`              | executable-smoke                                   | 3, 9                               | 15     | Packaged SimpleRPG usage lists road permutations in executable smoke.                            |
| `declarative-hex-worlds manifest`        | package-boundary, manifest-package                 | 12                                 | 0      | Package smoke validates the CLI manifest and packaged SimpleRPG imports together.                |
| `neutralUnitAssetId`                     | executable-smoke                                   | 14, 16, 17, 18                     | 25     | Packaged SimpleRPG usage resolves a neutral unit asset id in executable smoke.                   |
| `NOTICE.md`                              | package-boundary, manifest-package                 | 19                                 | 0      | Release/package audits keep KayKit attribution with the SimpleRPG packaged smoke.                |
| `package.json files`                     | package-boundary, manifest-package                 | 19                                 | 0      | Package audit verifies exports, files, examples, and SimpleRPG package imports.                  |
| `planGameboardInteractionCommand`        | fixed-gameplay                                     | 17                                 | 0      | Fixed SimpleRPG tests plan prop interaction and enemy attack commands.                           |
| `recommendExternalAssetFacing`           | executable-smoke, compatibility-adapter            | 16                                 | 0      | Packaged SimpleRPG usage recommends external asset facing in executable smoke.                   |
| `selectCoastVariant`                     | executable-smoke                                   | 7, 15                              | 10     | Packaged SimpleRPG usage selects a coast variant in executable smoke.                            |
| `selectCoastVariantByLabel`              | executable-smoke                                   | 7, 15                              | 10     | Packaged SimpleRPG usage selects a labeled coast variant in executable smoke.                    |
| `selectManifestAssets`                   | executable-smoke, manifest-package                 | 12                                 | 0      | Packaged SimpleRPG usage selects manifest assets in executable smoke.                            |
| `selectRiverCrossingVariant`             | executable-smoke                                   | 4, 7                               | 4      | Packaged SimpleRPG usage selects a river crossing variant in executable smoke.                   |
| `selectRiverVariant`                     | executable-smoke                                   | 4, 7                               | 26     | Packaged SimpleRPG usage selects a river variant in executable smoke.                            |
| `selectRiverVariantByLabel`              | executable-smoke                                   | 4, 7                               | 24     | Packaged SimpleRPG usage selects a labeled river variant in executable smoke.                    |
| `selectRoadVariant`                      | executable-smoke                                   | 3, 9                               | 15     | Packaged SimpleRPG usage selects a road variant in executable smoke.                             |
| `selectRoadVariantByLabel`               | executable-smoke                                   | 3, 9                               | 15     | Packaged SimpleRPG usage selects a labeled road variant in executable smoke.                     |
| `selectSpawnCoordinates`                 | executable-smoke                                   | 9                                  | 0      | Packaged SimpleRPG usage selects raw deterministic spawn coordinates in executable smoke.        |
| `spawnGameboardActor`                    | fixed-gameplay                                     | 14, 16, 17, 18                     | 137    | Fixed and seeded SimpleRPG fixtures spawn player, NPC, prop, and enemy actors.                   |
| `textureFileName`                        | executable-smoke                                   | 11, 12                             | 0      | Packaged SimpleRPG usage resolves a texture filename in executable smoke.                        |
| `validateGameboardRecipe`                | executable-smoke                                   | 11, 12, 13                         | 1      | Packaged SimpleRPG usage validates a compiled recipe in executable smoke.                        |
| `validateGameboardRecipeGeneration`      | executable-smoke                                   | 13                                 | 0      | Packaged SimpleRPG usage validates recipe generation config in executable smoke.                 |

## Gaps

[Section titled “Gaps”](#gaps)

* None

## Local References

[Section titled “Local References”](#local-references)

| Status    | Reference                     | Path                                                | Purpose                                                                        |
| --------- | ----------------------------- | --------------------------------------------------- | ------------------------------------------------------------------------------ |
| available | KayKit Medieval Hexagon FREE  | `references/KayKit_Medieval_Hexagon_Pack_1.0_FREE`  | FREE source pack for guide extraction, generated assets, and manifest audits.  |
| available | KayKit Medieval Hexagon EXTRA | `references/KayKit_Medieval_Hexagon_Pack_1.0_EXTRA` | Purchased local-only EXTRA pack for category and guide visual coverage.        |
| available | Kenney Castle Kit             | `references/kenney_castle-kit`                      | Third-party compatibility fixture for non-hex props, structures, and warnings. |
| available | KayKit Adventurers FREE       | `references/KayKit_Adventurers_2.0_FREE`            | Animated actor fixture for facing, spawn, and SimpleRPG local-asset coverage.  |

## Release Checks

[Section titled “Release Checks”](#release-checks)

| Status | Command                             | Summary                                                                                                                                                                                       |
| ------ | ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| passed | `pnpm lint`                         | Biome lint over workspace packages, docs scripts, and generated public TypeScript surfaces.                                                                                                   |
| passed | `pnpm typecheck`                    | Strict TypeScript validation for runtime, package tests, docs scripts, and generated examples.                                                                                                |
| passed | `pnpm build`                        | Nx package build including tsup ESM chunks, declarations, CLI shebang preservation, and asset copies.                                                                                         |
| passed | `pnpm test:ci`                      | Serialized non-browser release gate: docs contracts, API docs, assets, workspace/workflow audits, CLI smoke, expectations, unit tests, package audit, consumer smoke, and dry-run pack.       |
| passed | `pnpm test:docs-contract`           | Pillar frontmatter/link audit plus README, pillar, and guide SimpleRPG executable coverage contract for 40 guide-facing helper APIs, 404 KayKit public treatment records, and 19 guide pages. |
| passed | `pnpm expectations`                 | Behavior-drift fixtures for seeded generation, SimpleRPG quests, executable guide API smoke, movement, actor targets, patrols, mutations, and final placements.                               |
| passed | `pnpm docs:build`                   | TypeDoc and VitePress documentation build with public JSDoc and guide-link validation.                                                                                                        |
| passed | `pnpm test:consumer`                | Packed tarball installed into a temporary app, then compiled and executed through public subpaths, examples, and the CLI bin.                                                                 |
| passed | `pnpm test:visual`                  | FREE, EXTRA, SimpleRPG, Kenney Castle Kit, and KayKit Adventurers browser visual suites with screenshot quality checks.                                                                       |
| passed | `pnpm showcases:promote -- --check` | Curated browser screenshots match committed docs/package showcase copies and pass the shared PNG quality analyzer.                                                                            |
| passed | `pnpm test:workflows`               | CI, Release Please, npm OIDC publish, automerge, and Dependabot workflow contract audit.                                                                                                      |
| passed | `pnpm pack:dry-run`                 | npm tarball dry run proving publish whitelist, FREE asset inclusion, local reference exclusion, README gallery links, KayKit attribution/NOTICE, and packaged showcase PNG quality.           |

## Visual Artifacts

[Section titled “Visual Artifacts”](#visual-artifacts)

| Status    | Source     | Artifact                                                                                   | Pages          |
| --------- | ---------- | ------------------------------------------------------------------------------------------ | -------------- |
| available | guide      | `docs/assets/kaykit-guide/montage.png`                                                     | 1              |
| available | guide      | `docs/assets/kaykit-guide/pages/page-01.png`                                               | 1              |
| available | guide      | `docs/assets/kaykit-guide/pages/page-02.png`                                               | 2              |
| available | guide      | `docs/assets/kaykit-guide/pages/page-03.png`                                               | 3              |
| available | guide      | `docs/assets/kaykit-guide/pages/page-04.png`                                               | 4              |
| available | guide      | `docs/assets/kaykit-guide/pages/page-05.png`                                               | 5              |
| available | guide      | `docs/assets/kaykit-guide/pages/page-06.png`                                               | 6              |
| available | guide      | `docs/assets/kaykit-guide/pages/page-07.png`                                               | 7              |
| available | guide      | `docs/assets/kaykit-guide/pages/page-08.png`                                               | 8              |
| available | guide      | `docs/assets/kaykit-guide/pages/page-09.png`                                               | 9              |
| available | guide      | `docs/assets/kaykit-guide/pages/page-10.png`                                               | 10             |
| available | guide      | `docs/assets/kaykit-guide/pages/page-11.png`                                               | 11             |
| available | guide      | `docs/assets/kaykit-guide/pages/page-12.png`                                               | 12             |
| available | guide      | `docs/assets/kaykit-guide/pages/page-13.png`                                               | 13             |
| available | guide      | `docs/assets/kaykit-guide/pages/page-14.png`                                               | 14             |
| available | guide      | `docs/assets/kaykit-guide/pages/page-15.png`                                               | 15             |
| available | guide      | `docs/assets/kaykit-guide/pages/page-16.png`                                               | 16             |
| available | guide      | `docs/assets/kaykit-guide/pages/page-17.png`                                               | 17             |
| available | guide      | `docs/assets/kaykit-guide/pages/page-18.png`                                               | 18             |
| available | guide      | `docs/assets/kaykit-guide/pages/page-19.png`                                               | 19             |
| available | showcase   | `docs/assets/showcases/extra-blueprint-biome-transition-showcase.png`                      | -              |
| available | showcase   | `docs/assets/showcases/extra-harbor-gameboard.png`                                         | -              |
| available | showcase   | `docs/assets/showcases/free-blueprint-builder-showcase.png`                                | -              |
| available | showcase   | `docs/assets/showcases/free-guide-coasts-all-labels-rotations-water-waterless.png`         | -              |
| available | showcase   | `docs/assets/showcases/free-guide-rivers-all-labels-rotations-water-waterless.png`         | -              |
| available | showcase   | `docs/assets/showcases/free-guide-roads-all-labels-rotations.png`                          | -              |
| available | showcase   | `docs/assets/showcases/free-guide-scenarios-by-extracted-page.png`                         | -              |
| available | showcase   | `docs/assets/showcases/simple-rpg-fixed-completed.png`                                     | -              |
| available | showcase   | `docs/assets/showcases/simple-rpg-local-third-party-assets.png`                            | -              |
| available | showcase   | `docs/assets/showcases/simple-rpg-seeded-completed.png`                                    | -              |
| available | guide      | `NOTICE.md`                                                                                | 19             |
| available | showcase   | `docs/showcases/extra-blueprint-biome-transition-showcase.png`                             | -              |
| available | showcase   | `docs/showcases/extra-harbor-gameboard.png`                                                | -              |
| available | showcase   | `docs/showcases/free-blueprint-builder-showcase.png`                                       | -              |
| available | showcase   | `docs/showcases/free-guide-coasts-all-labels-rotations-water-waterless.png`                | -              |
| available | showcase   | `docs/showcases/free-guide-rivers-all-labels-rotations-water-waterless.png`                | -              |
| available | showcase   | `docs/showcases/free-guide-roads-all-labels-rotations.png`                                 | -              |
| available | showcase   | `docs/showcases/free-guide-scenarios-by-extracted-page.png`                                | -              |
| available | showcase   | `docs/showcases/simple-rpg-fixed-completed.png`                                            | -              |
| available | showcase   | `docs/showcases/simple-rpg-local-third-party-assets.png`                                   | -              |
| available | showcase   | `docs/showcases/simple-rpg-seeded-completed.png`                                           | -              |
| available | guide      | `tests/browser/__screenshots__/extra-blueprint-biome-transition-showcase.png`              | 9, 11, 13      |
| available | screenshot | `tests/browser/__screenshots__/extra-guide-assets-by-public-role.png`                      | -              |
| available | screenshot | `tests/browser/__screenshots__/extra-guide-scenarios-pages-02-15.png`                      | -              |
| available | screenshot | `tests/browser/__screenshots__/extra-guide-scenarios-pages-16-18.png`                      | -              |
| available | guide      | `tests/browser/__screenshots__/extra-harbor-gameboard.png`                                 | 7, 15          |
| available | guide      | `tests/browser/__screenshots__/extra-local-all-buildings-factions-neutral-harbors.png`     | 2, 15, 17      |
| available | guide      | `tests/browser/__screenshots__/extra-local-all-decoration-nature-props.png`                | 5, 16          |
| available | guide      | `tests/browser/__screenshots__/extra-local-all-tiles-guide-and-transitions.png`            | 11, 12, 13     |
| available | guide      | `tests/browser/__screenshots__/extra-local-all-units-full-accent-neutral-siege.png`        | 14, 16, 17, 18 |
| available | guide      | `tests/browser/__screenshots__/extra-seasonal-textures.png`                                | 11, 12, 13     |
| available | guide      | `tests/browser/__screenshots__/free-blueprint-builder-showcase.png`                        | 8, 9           |
| available | screenshot | `tests/browser/__screenshots__/free-catalog.png`                                           | -              |
| available | guide      | `tests/browser/__screenshots__/free-gameboard-recipe.png`                                  | 8, 9           |
| available | guide      | `tests/browser/__screenshots__/free-generated-piece-recipe.png`                            | 6              |
| available | screenshot | `tests/browser/__screenshots__/free-guide-assets-by-public-role.png`                       | -              |
| available | guide      | `tests/browser/__screenshots__/free-guide-coasts-all-labels-rotations-water-waterless.png` | 7              |
| available | guide      | `tests/browser/__screenshots__/free-guide-page-nature-stacks-buildings-props.png`          | 2, 5, 6, 8, 10 |
| available | guide      | `tests/browser/__screenshots__/free-guide-river-curvy-crossings-all-modes.png`             | 4              |
| available | guide      | `tests/browser/__screenshots__/free-guide-rivers-all-labels-rotations-water-waterless.png` | 4, 7           |
| available | guide      | `tests/browser/__screenshots__/free-guide-roads-all-labels-rotations.png`                  | 3              |
| available | screenshot | `tests/browser/__screenshots__/free-guide-scenarios-by-extracted-page.png`                 | -              |
| available | screenshot | `tests/browser/__screenshots__/free-guide-source-pages.png`                                | -              |
| available | guide      | `tests/browser/__screenshots__/free-seeded-gameboard.png`                                  | 9              |
| available | guide      | `tests/browser/__screenshots__/free-seeded-hex-gameboard.png`                              | 10             |
| available | guide      | `tests/browser/__screenshots__/simple-rpg-fixed-completed.png`                             | 9              |
| available | guide      | `tests/browser/__screenshots__/simple-rpg-local-third-party-assets.png`                    | 14             |
| available | screenshot | `tests/browser/__screenshots__/simple-rpg-packaged-scenario.png`                           | -              |
| available | guide      | `tests/browser/__screenshots__/simple-rpg-seeded-completed.png`                            | 18             |
| available | screenshot | `tests/browser/__screenshots__/simple-rpg-simulation-report.png`                           | -              |

## Guide Pages

[Section titled “Guide Pages”](#guide-pages)

| Page | Scenario                               | Edition   | Assets | APIs | Docs | Visuals | Source Image                                           |
| ---- | -------------------------------------- | --------- | ------ | ---- | ---- | ------- | ------------------------------------------------------ |
| 1    | `page-01-overview-and-license`         | reference | 0      | 3    | 3    | 2       | available `docs/assets/kaykit-guide/pages/page-01.png` |
| 2    | `page-02-buildings-props-and-factions` | mixed     | 164    | 16   | 2    | 2       | available `docs/assets/kaykit-guide/pages/page-02.png` |
| 3    | `page-03-road-variations`              | free      | 15     | 4    | 2    | 1       | available `docs/assets/kaykit-guide/pages/page-03.png` |
| 4    | `page-04-river-variations`             | free      | 30     | 7    | 2    | 2       | available `docs/assets/kaykit-guide/pages/page-04.png` |
| 5    | `page-05-nature-contents`              | free      | 77     | 13   | 2    | 2       | available `docs/assets/kaykit-guide/pages/page-05.png` |
| 6    | `page-06-nature-usage`                 | free      | 42     | 9    | 2    | 2       | available `docs/assets/kaykit-guide/pages/page-06.png` |
| 7    | `page-07-water-usage`                  | free      | 44     | 18   | 2    | 3       | available `docs/assets/kaykit-guide/pages/page-07.png` |
| 8    | `page-08-taller-hex-tiles`             | free      | 3      | 6    | 2    | 3       | available `docs/assets/kaykit-guide/pages/page-08.png` |
| 9    | `page-09-world-design-example`         | free      | 61     | 21   | 2    | 5       | available `docs/assets/kaykit-guide/pages/page-09.png` |
| 10   | `page-10-floating-islands`             | free      | 45     | 12   | 2    | 2       | available `docs/assets/kaykit-guide/pages/page-10.png` |
| 11   | `page-11-biomes`                       | extra     | 1      | 6    | 2    | 3       | available `docs/assets/kaykit-guide/pages/page-11.png` |
| 12   | `page-12-alternate-textures`           | extra     | 1      | 7    | 2    | 2       | available `docs/assets/kaykit-guide/pages/page-12.png` |
| 13   | `page-13-transition-tiles`             | extra     | 1      | 8    | 2    | 3       | available `docs/assets/kaykit-guide/pages/page-13.png` |
| 14   | `page-14-units`                        | extra     | 137    | 5    | 2    | 2       | available `docs/assets/kaykit-guide/pages/page-14.png` |
| 15   | `page-15-shipyard-harbors`             | mixed     | 25     | 13   | 2    | 2       | available `docs/assets/kaykit-guide/pages/page-15.png` |
| 16   | `page-16-stables-and-horses`           | extra     | 155    | 16   | 2    | 2       | available `docs/assets/kaykit-guide/pages/page-16.png` |
| 17   | `page-17-workshop-and-siege`           | extra     | 170    | 19   | 2    | 2       | available `docs/assets/kaykit-guide/pages/page-17.png` |
| 18   | `page-18-unit-combinations`            | extra     | 137    | 6    | 2    | 2       | available `docs/assets/kaykit-guide/pages/page-18.png` |
| 19   | `page-19-supporters-and-attribution`   | reference | 0      | 3    | 3    | 2       | available `docs/assets/kaykit-guide/pages/page-19.png` |

## Final Commands

[Section titled “Final Commands”](#final-commands)

* `pnpm lint`
* `pnpm typecheck`
* `pnpm build`
* `pnpm test:ci`
* `pnpm test:docs-contract`
* `pnpm expectations`
* `pnpm docs:build`
* `pnpm test:consumer`
* `pnpm test:visual`
* `pnpm showcases:promote -- --check`
* `pnpm test:workflows`
* `pnpm pack:dry-run`

# Rendering, assets, and external packs

> How the library ships assets, bootstraps FREE, and supports EXTRA + third-party packs.

The published package ships the FREE KayKit assets and manifest. Purchased EXTRA assets and third-party fixtures stay local-only unless an application chooses to copy its own generated manifest and source URL map into its codebase.

## FREE Assets

[Section titled “FREE Assets”](#free-assets)

Use `freeManifest` for packaged assets. It includes asset ids, categories, subcategories, factions, texture sets, bounds, material slots, local package paths, and KayKit license metadata.

```ts
import { freeManifest } from 'declarative-hex-worlds/manifest/free';
import {
  createManifestBundle,
  getManifestAsset,
  resolveManifestAssetUrl,
} from 'declarative-hex-worlds/manifest/schema';


const bundle = createManifestBundle([freeManifest]);
const asset = getManifestAsset(bundle, 'hex_river_A');


const url = asset
  ? resolveManifestAssetUrl(asset, {
      baseUrl: '/node_modules/declarative-hex-worlds/assets/free',
    })
  : undefined;
```

Browser bundles often rewrite package asset URLs. Keep that mapping at the app boundary instead of baking local absolute paths into manifests.

Use `describeKayKitAssetTreatment(assetId)` from `./catalog` when an editor or tool needs to explain what an asset is for. Treatment records connect each FREE/EXTRA asset id to a role, placement kind/layer, extracted guide image, and the public builder or selector API that exercises it. This prevents an asset from being merely present in a manifest without a gameboard-facing path. Use `listKayKitGuideScenarios()` when the tool needs the page-level source contract: each extracted guide page lists its source PNG, covered assets, public APIs, docs, and visual artifacts. Use `listKayKitGuideScenarioTreatments(id)` or `describeKayKitGuideScenarioCoverage(id)` to join a page back to the asset treatment records, `listKayKitGuideAssetCoverages()` when a tool needs to start from an exact asset id, `listKayKitGuideRoleCoverages()` when it needs to start from a gameplay role, `listKayKitGuidePublicApiCoverages()` when it needs to start from a public API surface, `listKayKitGuideScenarioAssetRenderRequests()` when it needs URL-resolved render queues, `listKayKitGuideScenarioAssetRenderGroups()` when it needs guide-page contact-sheet groups, `guide-render-requests` when it needs the same queue from the CLI, and `summarizeKayKitGuideCoverage()` when a build tool or editor needs stable counts for pages, editions, roles, unique assets, repeated page-level asset occurrences, docs, and visual artifacts.

## EXTRA Assets

[Section titled “EXTRA Assets”](#extra-assets)

EXTRA assets are supported through local ingest. They must not be published by this package. Apps that own the assets can generate an app-local manifest and combine it with the packaged FREE manifest:

```ts
import { freeManifest } from 'declarative-hex-worlds/manifest/free';
import { createManifestBundle } from 'declarative-hex-worlds/manifest/schema';
import extraManifest from './generated/kaykit-extra-manifest.json';


const bundle = createManifestBundle([freeManifest, extraManifest]);
```

The static `import extraManifest from '...json'` shown above assumes the generated manifest lives in your **source tree**. If you wrote it under a Vite `public/` root (the natural outcome of `extract --out public/assets/...`), Vite refuses to import it (“Assets in public directory cannot be imported from JavaScript”) — `fetch()` it at runtime instead and pass the parsed JSON to `createManifestBundle`.

Every placement that points at an EXTRA asset should keep `requiresExtra: true`. That lets validation and renderers distinguish missing local content from package bugs.

## Three.js Bridge

[Section titled “Three.js Bridge”](#threejs-bridge)

The `./three` subpath is a thin bridge around public board state. It does not own the game loop. Use it to:

* resolve a placement to a loadable URL.
* load GLTFs with an app-provided loader.
* apply position, rotation, scale, and placement metadata.
* keep a scene in sync with added, changed, and removed placements.
* tag objects so raycasts can resolve placement ids, tile keys, actor ids, and source asset ids.
* attach optional animation clips for rigged units.

```ts
import {
  createGameboardPlacementAssetUrlResolver,
  gameboardInteractionTargetForObject,
  syncGameboardPlacementObjects,
} from 'declarative-hex-worlds/three';


const sourceAssetUrls = runtime.createScenarioPieceSourceUrlMap({
  sourceRoots: { 'Kenney Castle Kit': '/assets/kenney/castle-kit' },
});
const resolveAssetUrl = createGameboardPlacementAssetUrlResolver({
  catalog: manifestBundle,
  assetUrls: sourceAssetUrls,
  baseUrl: '/assets/kaykit/free',
});
const previewUrl = resolveAssetUrl(runtime.plan().placements[0]);


const sync = await syncGameboardPlacementObjects(runtime.plan().placements, {
  parent: scene,
  loader,
  catalog: manifestBundle,
  assetUrls: sourceAssetUrls,
  baseUrl: '/assets/kaykit/free',
});


const target = gameboardInteractionTargetForObject(raycasterHit.object);
```

Animation loading is explicit because different games manage mixers and clips differently. The bridge exposes clip metadata so an app can connect the loaded clips to its own animation system.

### Performance at scale

[Section titled “Performance at scale”](#performance-at-scale)

`syncGameboardPlacementObjects` (and `loadGameboardPlacementObject`) dedupe GLTF loads by URL automatically: placements that resolve to the same model or animation URL trigger exactly one `loader.loadAsync` call per sync generation, no matter how many placements share it. A failed load is evicted from the cache so the next sync retries instead of caching the failure. This is on by default; pass `cacheLoads: false` if a caller needs every placement to issue its own load.

Deduping loads does not change the draw-call story: each placement still gets its own cloned `Object3D` subtree. A single-mesh asset is one draw call per placement; multi-mesh or multi-material GLTFs (rigged units especially) issue one draw call per mesh/material group. For a 98-placement showcase board of mostly single-mesh tiles this measures as 98 draw calls (`renderer.info.render.calls`) — fine at that scale. Boards with hundreds to thousands of tiles should batch per-asset-id with `THREE.InstancedMesh` on top of the placement snapshot the bridge already produces; the bridge intentionally doesn’t own that batching decision.

## External Compatibility

[Section titled “External Compatibility”](#external-compatibility)

Run compatibility checks on local GLB/GLTF files before registering them as pieces. A mesh that is not a KayKit-compatible hex tile can still be useful as a prop, landmark, building, tree, scatter item, or unit.

```bash
declarative-hex-worlds compatibility \
  --asset "references/kenney_castle-kit/Models/GLB format/tower-hexagon-base.glb" \
  --intendedRole tile \
  --sourcePack "Kenney Castle Kit" \
  --modelForward +z \
  --boardForwardEdge 1


declarative-hex-worlds pieces-from-assets \
  --assets "references/kenney_castle-kit/Models/GLB format" \
  --sourcePack "Kenney Castle Kit" \
  --intendedRole tile \
  --assetIdPrefix kenney \
  --pieceIdPrefix kenney-castle \
  --tags castle \
  --pieceOverrides docs/examples/local-piece-overrides.kenney-castle.json \
  --includeReports \
  --out /tmp/kenney-pieces.json
```

The batch output omits absolute paths by default. Renderer URL maps should be generated from local source roots at app build time:

```bash
declarative-hex-worlds pieces \
  --pieces /tmp/kenney-pieces.json \
  --emitSourceUrls \
  --pieceSourceRoots docs/examples/local-piece-source-roots.example.json \
  --json
```

## Placement Criteria

[Section titled “Placement Criteria”](#placement-criteria)

Use explicit criteria for non-KayKit assets:

* towers and large structures usually need multi-tile footprints and occupancy reservations.
* trees and loose props should use scatter slots, `maxPerTile`, and a soft slot group.
* units should declare facing and animation expectations.
* circular towers, square walls, and other non-hex meshes should be props or landmarks unless the compatibility report proves a matching tile footprint.
* ships, docks, ports, and harbor props should target coast tiles adjacent to water.

This placement metadata is what lets seeded boards stay plausible while still accepting assets from another designer.

## Browser Verification

[Section titled “Browser Verification”](#browser-verification)

Rendering tests should exercise public fixtures:

```bash
pnpm test:browser:free
pnpm test:browser:extra
pnpm test:e2e:local-assets
pnpm test:visual
```

Screenshots are deterministic artifacts. The test suite checks image size, variance, and flat-output failures after Chromium captures the PNGs. When adding new visible behavior, prefer a scenario or recipe fixture that can also be used by CLI validation and headless simulation tests. The FREE browser suite also captures `free-guide-source-pages.png` and `free-guide-scenarios-by-extracted-page.png` so visual review can start from the decomposed KayKit guide pages and then inspect every FREE treatment associated with those pages. The EXTRA browser suite follows the same page contract through `extra-guide-scenarios-pages-02-15.png` and `extra-guide-scenarios-pages-16-18.png`, covering mixed and EXTRA page-level asset occurrences for buildings, transitions, units, harbors, stables, workshops, siege pieces, and unit combinations.

# Runtime integration

> Wire the runtime facade into a React + Three.js app.

Use the runtime facade as the application boundary for a playable board. The lower-level modules remain public, but a game usually wants one object that owns the Koota world, exposes safe mutations, projects render plans, runs systems, and emits snapshots for UI or another ECS.

## Runtime Ownership

[Section titled “Runtime Ownership”](#runtime-ownership)

A scene should create exactly one runtime for one board instance:

* Use `createGameboardRuntime(plan)` when the app already has a validated `GameboardPlan`.
* Use `createGameboardRuntimeFromRecipe(recipe)` when the app loads saved board intent and still needs recipe-local piece registries.
* Use `createGameboardRuntimeFromScenario(scenario)` when the app loads actors, movement agents, patrols, quests, spawn groups, or SimpleRPG-style fixtures.

The runtime keeps `runtime.world` public so advanced users can run raw Koota queries or mount the world in React. Prefer the facade methods first when code is about gameplay, editor previews, save data, or integration tests; those methods project live board state before navigation, layout, and interop reads.

## Play Loop

[Section titled “Play Loop”](#play-loop)

The common loop is deterministic:

1. Validate the recipe, scenario, or plan before startup.
2. Create the runtime.
3. Spawn or register any transient scene actors and props.
4. Convert pointer/raycast targets into commands.
5. Dispatch commands and run system ticks.
6. Render `runtime.plan()` or `runtime.snapshot().plan`.
7. Mirror `runtime.createInteropSnapshot()` into another ECS if needed.

```ts
import {
  createGameboardRuntimeFromScenario,
} from 'declarative-hex-worlds/runtime';
import {
  createGameboardInteractionHandlerPreset,
} from 'declarative-hex-worlds/commands';


const runtime = createGameboardRuntimeFromScenario(scenario);
const handlers = createGameboardInteractionHandlerPreset('default-rpg');


function frame(step: number, clickedTarget?: string) {
  if (clickedTarget) {
    runtime.dispatchCommand(clickedTarget, {
      sourceActor: 'player',
      handlers,
      systems: false,
    });
  }


  const tick = runtime.tick({
    patrols: true,
    movement: { steps: 4 },
    quests: { step },
  });


  renderBoard(runtime.plan());
  updateHud(runtime.readActors(), runtime.readQuests(), tick.eventRecords);
}
```

## Runtime Mutations

[Section titled “Runtime Mutations”](#runtime-mutations)

Runtime placements are for gameplay state that changes after startup: units, construction previews, dropped props, markers, blockers, and temporary effects. Use occupancy preflight when a placement can block movement or reserve a footprint.

```ts
const preview = runtime.inspectPlacementOccupancy({
  at: '2,1',
  kind: 'structure',
  footprint: { kind: 'adjacent', edges: [0, 1], includeCenter: true },
});


if (preview.canOccupy) {
  const tower = runtime.spawnPlacement({
    id: 'watchtower-01',
    at: '2,1',
    assetId: 'kenney:round-tower',
    kind: 'structure',
    occupancyGuard: true,
  });


  runtime.registerActor(tower, {
    actorId: 'watchtower-01',
    actorKind: 'prop',
    blocking: true,
    tags: ['player-built'],
  });
}
```

Use `runtime.readPlacements()` and `runtime.readPlacementOccupancy()` for whole board save files, editor panels, and bridge code. Use `runtime.readPlacementsForTile(tileKey)` and `runtime.readPlacementOccupancyForTile(tileKey)` when a hover panel, collision probe, or host ECS sync only needs one hex. Use `runtime.readActorsForTile(tileKey)` when that same one-hex read needs actor kinds, teams, hostility, tags, or interaction flags rather than raw placement records. Use `runtime.removePlacement(id)` for cleanup; it removes the placement entity and its placement relations so future navigation and occupancy reads use the current world.

Use `runtime.summarizePlan()` when a tool needs aggregate coverage from the current live board instead of raw placement arrays. It returns counts by terrain, texture set, elevation, tile tag, placement kind/layer, semantic feature, asset id, and local-only asset usage. The same pure helper is available as `summarizeGameboardPlan(plan)` for build-time recipes, browser screenshot manifests, editor sidebars, and ECS bridge preflight checks.

## Actor And Quest Reads

[Section titled “Actor And Quest Reads”](#actor-and-quest-reads)

Actors are placement-backed. That keeps render transforms, collision, target selection, and quest objectives tied to the same tile occupancy model.

```ts
const nearbyEnemies = runtime.selectActors({
  sourceActor: 'player',
  hostileToSource: true,
  radius: 4,
  sort: 'distance',
});


const targetPlan = runtime.inspectActorTargets({
  sourceActor: 'player',
  hostileToSource: true,
  maxPathCost: 6,
});


if (targetPlan.nearestTarget) {
  runtime.interactActorTarget(
    { sourceActor: 'player', targetActorId: targetPlan.nearestTarget.actor.actorId },
    { handlers, systems: { movement: false, quests: true } }
  );
}


for (const quest of runtime.advanceAllQuests({ step: frameNumber })) {
  if (quest.quest.status === 'completed') {
    unlockReward(quest.quest.questId);
  }
}
```

## Seeded Scene Assembly

[Section titled “Seeded Scene Assembly”](#seeded-scene-assembly)

Random board generation should still be inspectable before it mutates the live world. Analyze fills first, then spawn the same rules after the app accepts the diagnostics.

```ts
const fill = {
  seed: 'campaign-01:forest',
  rules: [{ id: 'trees', archetype: 'tree', assetId: 'tree_single_A', fill: 0.18 }],
} as const;


const analysis = runtime.analyzeLayoutFill(fill);
if (analysis.errors.length === 0) {
  runtime.spawnLayoutFill(fill);
}


const spawnPlan = runtime.planSpawnGroups({
  seed: 'campaign-01:encounters',
  groups: [
    { id: 'player', count: 1, tileTags: ['player-spawn'] },
    { id: 'enemy', count: 3, minDistanceFromGroups: 4, pathToGroups: ['player'] },
  ],
});
```

Keep seed namespaces stable. Board terrain, layout fills, piece fills, spawn groups, patrol plans, and combat randomness should not all consume one stream if the game needs reproducible maps across content edits.

## React Runtime Boundary

[Section titled “React Runtime Boundary”](#react-runtime-boundary)

React components can mount a runtime created outside React with `GameboardRuntimeProvider`, or load content directly with `GameboardPlanProvider`, `GameboardRecipeProvider`, and `GameboardScenarioProvider`.

Use hook families by intent:

| Intent                              | Hooks                                                                                                                                                                                                                                                                               |
| ----------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Runtime and snapshots               | `useGameboardRuntime`, `useGameboardRuntimeSnapshot`, `useProjectedGameboardPlan`                                                                                                                                                                                                   |
| Mutable gameplay actions            | `useGameboardActions`, `useGameboardActorActions`, `useGameboardCommandActions`, `useGameboardMovementActions`, `useGameboardPatrolActions`, `useGameboardQuestActions`, `useGameboardSystemActions`                                                                                |
| Serializable reads                  | `useGameboardPlacementSnapshots`, `useGameboardActorSnapshots`, `useGameboardQuestSnapshots`, `useGameboardPlacementOccupancy`                                                                                                                                                      |
| Tile-local UI and collision probes  | `useGameboardTileInspection`, `useGameboardNeighborhoodInspection`, `usePlacementOccupancyForTile`, `useGameboardActorsForTile`, `usePlacementEntitiesForTile`, `useOriginPlacementEntitiesForTile`                                                                                 |
| Actor commands and target overlays  | `useGameboardActorSelection`, `useGameboardActorTargets`, `useGameboardActorTargetCommand`, `useGameboardInteractionTarget`, `useGameboardInteractionCommand`, `useGameboardInteractionCommandPreview`                                                                              |
| Navigation and spawned NPC setup    | `useGameboardOccupancyIndex`, `useGameboardNavigation`, `useGameboardSpawnLocations`, `useGameboardPatrolRoute`, `useGameboardPatrolRoutes`                                                                                                                                         |
| Build cursors and generated content | `useGameboardLayoutSiteInspection`, `useGameboardLayoutFillAnalysis`, `useGameboardLayoutPlacements`, `useGameboardPieceRegistryAnalysis`, `useGameboardPieceSelection`, `useGameboardPiecePlacementInspection`, `useGameboardPieceFillInspection`, `useGameboardPieceSourceUrlMap` |
| Raw Koota trait reads               | entity queries such as `useGameboardTileEntities`, plus trait hooks such as `useTileCoordinates`, `usePlacementState`, `useGameboardActor`, and `useGameboardQuest`                                                                                                                 |
| Live rule checks                    | `useGameboardPlacementOccupancyInspection`, `useCanOccupyGameboardPlacement`, `useGameboardRuleViolations`                                                                                                                                                                          |

Those hooks subscribe to trait and relation value changes, so moving an existing entity in place rerenders the UI even when query membership does not change.

## External ECS Bridge

[Section titled “External ECS Bridge”](#external-ecs-bridge)

Use interop snapshots when a host game already owns the simulation ECS but wants KayKit-aware board rules.

```ts
const snapshot = runtime.createInteropSnapshot({
  includeActors: true,
  includeQuests: true,
});


externalEcs.apply(snapshot.entities, snapshot.relations);
```

For callback-style stores, `runtime.mountInterop(adapter)` sends the same snapshot through an adapter and returns the host-entity mapping.

## Integration Tests

[Section titled “Integration Tests”](#integration-tests)

Integration tests should use the public runtime the same way a game does:

* Load a fixed scenario and assert the golden path.
* Load a seeded scenario with stable seed namespaces and assert the chosen board, actors, quests, collisions, and routes.
* Dispatch commands through `runtime.dispatchCommand` or `runtime.interactActorTarget` instead of calling lower-level movement helpers directly.
* Run `runtime.tick` for patrols, movement, commands, and quests.
* Capture browser screenshots from `runtime.plan()` and assert the generated files are nonblank.

The package SimpleRPG browser tests follow this pattern for fixed and seeded boards, local-only external pieces, actor targeting, collision, and quest completion.

# Testing

> The unit + browser + e2e test trinity, coverage gates, SimpleRPG-as-driver, perf benches.

## The test trinity

[Section titled “The test trinity”](#the-test-trinity)

Three vitest harnesses + one perf harness. Coverage from all of them feeds into a merged report (PRD R6).

| Harness                    | Config                                  | Includes                                                                                                                       | Cadence                                                                          |
| -------------------------- | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------- |
| **Unit**                   | `vitest.config.ts`                      | `src/**/__tests__/*.test.ts`, `tests/unit/**/*.test.ts`, `tests/integration/**/*.test.ts`                                      | every PR (`pnpm test`)                                                           |
| **Browser FREE**           | `vitest.browser.free.config.ts`         | `tests/browser/{free-visual,simple-rpg-visual,react-bindings}.test.ts`, `tests/browser/feature-gallery.spec.ts`, harness smoke | required merged coverage job on every PR; full screenshot command is local proof |
| **Browser EXTRA**          | `vitest.browser.extra.config.ts`        | `tests/browser/extra-visual.test.ts`                                                                                           | local-only with `HEX_WORLDS_ENABLE_EXTRA=1`                                      |
| **E2E local-assets**       | `vitest.browser.local-assets.config.ts` | `tests/e2e/local-assets/**/*.test.ts`                                                                                          | local-only with `HEX_WORLDS_ENABLE_LOCAL_ASSETS=1`                               |
| **SimpleRPG e2e (GitHub)** | `vitest.simple-rpg-e2e.config.ts`       | `tests/e2e/simple-rpg-ci.test.ts`                                                                                              | scheduled CI with `HEX_WORLDS_E2E_GITHUB=1`                                      |
| **SimpleRPG e2e (local)**  | `vitest.simple-rpg-e2e.config.ts`       | `tests/e2e/simple-rpg-local-extra.test.ts`                                                                                     | local with `HEX_WORLDS_LOCAL_REFERENCES=1`                                       |
| **Perf bench**             | n/a — direct vitest bench               | `tests/perf/*.bench.ts`                                                                                                        | local-only, non-blocking                                                         |

## Coverage gates

[Section titled “Coverage gates”](#coverage-gates)

`vitest.coverage.shared.ts` exports `COVERAGE_THRESHOLDS` at the current floor. PRD A8 ratchets these toward 100/100/100/100 via Epic E0-E10; each commit that closes a coverage gap raises the floor in the same commit.

CI’s required `Coverage` job bootstraps FREE models, collects unit coverage, collects browser-free coverage, then runs `pnpm coverage:merge:enforce`; regressions block merge.

To merge harness reports locally:

```bash
HEX_WORLDS_COVERAGE=1 pnpm coverage:all
open coverage/merged/lcov-report/index.html
```

## SimpleRPG: the coverage driver

[Section titled “SimpleRPG: the coverage driver”](#simplerpg-the-coverage-driver)

`tests/integration/simple-rpg/simple-rpg.ts` is a 1,005-line driver that exercises 80+ public APIs synchronously. Its purpose isn’t gameplay — it’s coverage. Read the [SimpleRPG README](https://github.com/jbcom/declarative-hex-worlds/tree/main/tests/simple-rpg/README.md) for the API matrix.

Three entry-point functions matter:

* `runSimpleRpgUsageExample()` — full scenario → simulation → snapshot path; returns a `SimpleRpgUsageSummary` with every metric the coverage ledger needs.
* `summarizeSimpleRpgGuidePublicApiExercises()` — pure-data coverage map; safe to call repeatedly (no koota worlds).
* `runSimpleRpgExecutableGuideApiSmoke()` — executable smoke of every guide-page helper API.

The CLI’s `coverage` subcommand consumes these to emit `docs/release-readiness.json` + Markdown ledgers.

## Perf benches

[Section titled “Perf benches”](#perf-benches)

`tests/perf/warm-start.bench.ts` (PRD A3b) tracks the cost of blueprint → board → koota runtime → facade snapshot. Run:

```bash
pnpm bench:warm-start
```

Baseline as of 2026-05-26: \~27 Hz / 37 ms mean.

Add more benches to `tests/perf/` as PRD B/D-series perf work lands. The bench harness is opt-in (not in default `pnpm test`).

## Visual regression

[Section titled “Visual regression”](#visual-regression)

`tests/browser/__screenshots__/` holds committed PNG snapshots that vitest-browser compares against every render. Drift fails the build until either the diff is accepted (new snapshot committed) or fixed.

The screenshot assertion script is `tests/scripts/assert-screenshots.ts`; local visual commands call it via `pnpm test:screenshots:free` + `:extra` + `:local-assets`.

## What CI actually runs

[Section titled “What CI actually runs”](#what-ci-actually-runs)

See `.github/workflows/ci.yml`. The chain (post-PRD A9 install-once):

1. `install` job — `pnpm install --frozen-lockfile` once, uploads `node_modules.tar.zst` artifact.
2. `check` matrix — `lint`, `typecheck`, `build`, `test` (each downloads + restores the artifact).
3. `coverage` — bootstraps FREE models, collects unit + browser-free coverage, then enforces the merged ratchet.
4. `docs-site` — Astro Starlight build with generated CLI reference.
5. `dependency-review` — fail-on-severity: high.
6. `semgrep` — OWASP Top 10 + Node.js SAST.

Local proof uses `pnpm verify` for the fast source gates and `pnpm coverage:all:enforce` for the CI-shaped merged coverage gate.

# Tilesets

> Declare a sprite-sheet tileset, resolve biomes to cells, and render seamless painterly hex terrain in three.js or canvas-2D.

A **tileset** renders each hex as a cell of a sprite sheet — a painterly 2D/2.5D alternative to the 3D GLTF model path. It’s how you get continuous, illustrated terrain (grass, coast, mountains) instead of discrete meshes. The same declared tileset drives both the three.js and canvas-2D bindings.

## The manifest

[Section titled “The manifest”](#the-manifest)

A tileset is described by a `TilesetManifest`: named **sheets** (each a PNG with a cell grid) and a **biome → sheet** map.

```ts
import { parseTilesetManifest } from 'declarative-hex-worlds/asset-source';


const manifest = parseTilesetManifest({
  schemaVersion: '1',
  kind: 'tileset',
  sheets: {
    grassland: {
      url: '/assets/tilesets/grassland.png',
      // The sheet is a cols×rows grid of cellWidth×cellHeight px cells.
      grid: { cols: 5, rows: 10, cellWidth: 96, cellHeight: 83 },
      role: 'fill',
    },
    coast: {
      url: '/assets/tilesets/coast.png',
      grid: { cols: 4, rows: 4, cellWidth: 64, cellHeight: 64 },
      role: 'transition',
      // A transition sheet maps an edge mask → a specific cell index.
      edgeCells: { '5': 3, '10': 7 },
    },
  },
  biomes: {
    meadow: { sheet: 'grassland', select: 'hash' }, // pick a fill cell by tile-key hash
  },
});
```

* **`role: 'fill'`** — cells are interchangeable variations of one biome; `select` is `'hash'` (stable per-tile pick) or `'first'`.
* **`role: 'transition'`** — cells are positional; an edge mask selects a specific cell via `edgeCells` (see [Transitions](#transitions)).

`parseTilesetManifest` throws a precise Zod error on a malformed manifest, so bad data fails at the boundary, not deep in rendering.

## The source

[Section titled “The source”](#the-source)

`createTilesetSource` turns the manifest into an `AssetSource` — the neutral resolution seam a binding dispatches on:

```ts
import { createTilesetSource } from 'declarative-hex-worlds/asset-source';


const source = createTilesetSource({ manifest });
// resolve a placement (its metadata.biome or assetId names the biome) → a
// { type: 'tileset-cell', shape: 'quad', cell, hex, sheetUrl } render request.
```

Options:

* **`shape`** — `'quad'` (default) draws the full cell as a rectangle; painterly hex atlases paint each cell as a hex with transparent corners, so a full quad lets neighbours’ opaque bodies fill each other’s corners into **seamless** terrain. `'hex'` clips to a hexagon (only for cells that are opaque edge-to-edge).
* **`hex`** — override the world footprint of a cell (see [Seamless tessellation](#seamless-tessellation)).

## Rendering with `<HexWorld>` (three.js)

[Section titled “Rendering with \<HexWorld> (three.js)”](#rendering-with-hexworld-threejs)

The declarative element layer registers the source and renders the cells:

```tsx
import { Canvas } from '@react-three/fiber';
import { parseTilesetManifest, tilesetHexGeometry } from 'declarative-hex-worlds/asset-source';
import { HexWorld, Tileset, Tile, GameboardObjects } from 'declarative-hex-worlds/react-elements';


function Board({ plan, textureLoader }) {
  const geometry = tilesetHexGeometry(manifest); // see below
  return (
    <Canvas>
      <HexWorld plan={plan} textureLoader={textureLoader} geometry={geometry}>
        <Tileset manifest={manifest} />
        <Tile at="0,0" assetId="meadow" biome="meadow" />
        {/* …one <Tile> per hex, or let a projected plan carry the biomes… */}
        <GameboardObjects />
      </HexWorld>
    </Canvas>
  );
}
```

* **`<Tileset manifest>`** registers the source. Pass `hex` to override the cell footprint.
* **`<Tile at biome>`** declares a hex’s biome. The biome is carried on the placement’s `metadata.biome`, which survives the tile→runtime→projection round-trip (a biome baked only into a *plan* placement’s `assetId` is re-derived away — declare it via `<Tile>` or the tile’s terrain).
* **`<GameboardObjects>`** is the render bridge: it reconciles each resolved cell into a textured-hex mesh every frame. It is required — `<Tileset>` alone registers the source but draws nothing.
* **No GLTF `loader`** is needed for a tileset-only board — only a `textureLoader` (a three `TextureLoader` wrapped to report the sheet’s pixel size; see `GameboardSheetTextureLoader`).

## Rendering with canvas-2D

[Section titled “Rendering with canvas-2D”](#rendering-with-canvas-2d)

The `/canvas2d` binding draws the same declared source with zero renderer deps — `drawImage` blits each cell onto a 2D context:

```ts
import { syncCanvas2dPlacements } from 'declarative-hex-worlds/canvas2d';


syncCanvas2dPlacements(ctx, plan.placements, { source, sheets });
```

Its existence is the proof the resolution seam is substrate-agnostic: one declared tileset, two renderers.

## Seamless tessellation

[Section titled “Seamless tessellation”](#seamless-tessellation)

Painterly hex atlases bake a **vertically-foreshortened** (isometric) hex into each cell — e.g. a 96×83 cell is a pointy hex squashed from its regular 96×110. Two knobs make such cells tessellate into continuous terrain:

* **`tilesetHexGeometry(manifest)`** derives the board *placement* geometry (row spacing) from the cell aspect, so rows pack tight enough to interlock. Pass it to `<HexWorld geometry>` (or `projectWorldToGameboardPlan(world, { geometry })`), and use the **same** geometry for any unit/overlay coordinate conversion so they share the board’s space.
* The default cell footprint oversizes the quad past the grid pitch so the alpha-cutout hexes overlap into seamless terrain. The material uses `alphaTest` (a hard cutout) so a cell’s transparent corners never occlude the neighbour behind them.

## Transitions

[Section titled “Transitions”](#transitions)

A coast/river/road tile carries a non-zero `metadata.edgeMask`. The source’s `resolveEdge(assetId, edgeMask)` selects the positional transition cell for that mask via the sheet’s `edgeCells`; both the three and canvas-2D bindings dispatch through `resolveEdge` before the plain fill resolve, so transition art renders in place of a flat fill tile.

## From a scanned or downloaded pack

[Section titled “From a scanned or downloaded pack”](#from-a-scanned-or-downloaded-pack)

`createTilesetSource` takes a hand-authored manifest, but you can also build a source from a scanned/downloaded [`AssetSourceSpec`](/declarative-hex-worlds/guides/cli-reference/) (the `bind` CLI output, or a bundled pack) via `createSourceFromSpec(spec)` — it maps the spec’s `tileset`-role assets into the tileset source and composites them with any model sources.

# About

> Architecture, design, testing, deployment, and state of declarative-hex-worlds.

Architecture, design, testing, deployment, and state docs land in **F-Audit-9** through **F-Audit-13**. The library’s PRD lives at `docs/PRD/1.0.md` in the repo.

# Architecture

> How declarative-hex-worlds is organized — 20 domain sub-packages, koota ECS runtime, three-layer build pipeline.

The library is one published npm package (`declarative-hex-worlds`) that internally decomposes into 20 domain sub-packages under `src/`. Cross-domain imports traverse barrel re-exports only — Biome’s `noRestrictedImports` rule enforces it.

## Sub-package map

[Section titled “Sub-package map”](#sub-package-map)

| Sub-package               | Purpose                                                                                                              | Public surface                                                |
| ------------------------- | -------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------- |
| `traits/`                 | koota trait declarations (37 traits)                                                                                 | `declarative-hex-worlds/traits`                               |
| `types/`                  | Branded primitives + interface definitions                                                                           | `declarative-hex-worlds/types`                                |
| `coordinates/`            | Hex algebra, projection, grid layout, world↔hex transforms                                                           | `/coordinates`, `/grid`, `/layout`, `/projection`             |
| `manifest/`               | KayKit pack manifest schema + the autogenerated FREE manifest                                                        | `/manifest/schema`, `/manifest/free`                          |
| `ingest/`                 | Node-side asset ingest, source-root validation, manifest generation                                                  | `/ingest`                                                     |
| `cli/commands/bootstrap/` | CLI `bootstrap` subcommand + programmatic API; downloads + verifies KayKit assets; layout descriptors                | `/bootstrap`, `/bootstrap/upstream-layout`                    |
| `gameboard/`              | Plan builders, terrain/connectivity placement construction, occupancy-backed navigation, spawn groups, patrol routes | `/gameboard`, `/navigation`, `/occupancy`                     |
| `pieces/`                 | Custom piece declarations + cross-kit compatibility                                                                  | `/pieces`                                                     |
| `rules/`                  | Plan + scenario validation, layout fill rules                                                                        | `/rules`, `/validation`, `/rule-types`                        |
| `scenario/`               | Recipe → blueprint → scenario compilation, catalog queries, guide-page data, public treatment construction           | `/scenario`, `/recipe`, `/blueprint`, `/catalog`, `/registry` |
| `actors/`                 | Actor traits, queries, registration, navigation profiles, targets                                                    | `/actors`                                                     |
| `movement/`               | Movement agents + step execution                                                                                     | `/movement`                                                   |
| `patrol/`                 | Patrol routes + assignment + scripted patrol simulation                                                              | `/patrol`                                                     |
| `quests/`                 | Quest entities, objectives, progress, completion                                                                     | `/quests`                                                     |
| `commands/`               | Interaction handler presets, command planning                                                                        | `/commands`                                                   |
| `selectors/`              | Internal selector helpers (`@internal`-tagged)                                                                       | `/selectors`                                                  |
| `koota/`                  | createWorld + per-tile/per-actor spawn helpers                                                                       | `/koota`                                                      |
| `runtime/`                | Runtime facade for snapshots + asset-root resolution                                                                 | `/runtime`                                                    |
| `systems/`                | Command dispatch, per-tick movement/patrol/quest orchestration, rules                                                | `/systems`, `/world-rules`                                    |
| `simulation/`             | Scripted scenario simulation engine                                                                                  | `/simulation`                                                 |
| `interop/`                | Neutral ECS snapshot, external asset compatibility, release-readiness coverage                                       | `/interop`, `/compatibility`, `/coverage`                     |
| `react/`                  | React bindings: provider, hooks, selectors                                                                           | `/react`                                                      |
| `three/`                  | three.js bindings: loaders, scene helpers, animation                                                                 | `/three`                                                      |
| `cli/`                    | The `declarative-hex-worlds` Node binary                                                                             | `/cli`                                                        |
| `errors/`                 | 7-class taxonomy: `GameboardError` + 6 subclasses                                                                    | `/errors`                                                     |

## Interop and release coverage

[Section titled “Interop and release coverage”](#interop-and-release-coverage)

`interop/` has two deliberately separate jobs:

* Runtime interop lives in `interop.ts` and `compatibility.ts`. These modules normalize live ECS state into neutral snapshots and adapt external assets so games can inspect, serialize, and bridge runtime data.
* Release-readiness interop lives in `coverage.ts`. It aggregates guide-page coverage, manifest compatibility, required screenshot artifacts, local reference-pack status, and package/CI gate results into the `/coverage` maintainer-facing report.

Keeping release coverage beside runtime interop is intentional: the release ledger exists to prove that the public interop promises are backed by docs, assets, visuals, and package checks. Runtime consumers should reach for `/interop` or `/compatibility`; maintainers and CI use `/coverage` to audit release evidence.

## ECS layering

[Section titled “ECS layering”](#ecs-layering)

The runtime is built on [koota](https://koota.dev). koota’s discipline:

1. **Traits** (`traits/`) declare the data — pure data, no behavior.
2. **Systems** (`systems/`) read traits, decide what to do, mutate traits. Pure functions over `world`.
3. **Actions** (the `*Actions` exports in each domain) are the bundled mutations consumers call.
4. **Selectors / Queries** read traits without mutation.

The library follows that discipline strictly. `src/traits/` exports every trait declaration in one barrel so cross-package trait identity stays stable (PRD invariant §6: `splitting: true` + trait identity test E4 pin this).

## Build pipeline

[Section titled “Build pipeline”](#build-pipeline)

`tsup` builds with `splitting: true` so each subpath in `package.json#exports` becomes its own chunk. Trait identity survives across chunks (E4 tests it). `sideEffects: false` is on so consumers tree-shake aggressively.

The pipeline runs `tsc --noEmit` for typechecking, then `tsup` for both JS + DTS bundling. The two-pass approach (instead of `tsup --dts` only) keeps cycle-detection separate from bundling.

## Asset model

[Section titled “Asset model”](#asset-model)

Per PRD §Phase RB, the library is **bootstrap-not-bundle**:

* The published tarball ships only `assets/free/manifest.json` (the metadata).
* The actual GLTF tree is fetched at install time by `pnpm exec declarative-hex-worlds bootstrap`.
* The bootstrap-target lives under `<consumer-out>/addons/kaykit_medieval_hexagon_pack/Assets/gltf/`.
* A `.bootstrap.json` integrity sidecar records per-file SHA256 + library version + source URL.

See the [asset bootstrap guide](/guides/asset-bootstrap/) for usage and the [bootstrap layout reference](/reference/asset-bootstrap-layout/) for the upstream tree spec.

## Source-of-truth

[Section titled “Source-of-truth”](#source-of-truth)

`docs/PRD/1.0.md` in the repo holds the rationale for every architectural choice. `.agent-state/directive.md` holds the work queue. Both are tracked in git; if you see a layout decision that’s confusing, check the PRD for the why.

# Deployment

> Release flow, OIDC publish, GitHub App auth, SBOM, SLSA L3 attestation.

## Release flow

[Section titled “Release flow”](#release-flow)

Releases are driven by [release-please](https://github.com/googleapis/release-please-action) and Conventional Commits.

1. Contributor lands a PR on `main` with a Conventional Commits message (`feat:`, `fix:`, `chore:`, etc.).

2. `.github/workflows/cd.yml`’s `release-please` job opens (or updates) a release PR that bumps the version + writes the changelog entry.

3. Maintainer reviews the computed version and changelog, waits for required checks, then merges the release PR.

4. release-please tags the commit + creates a GitHub Release.

5. `.github/workflows/release.yml` fires on the release-published event and:

   * Builds the package.
   * Packs the tarball via `npm pack`.
   * Attests SLSA L3 build provenance.
   * Generates a CycloneDX SBOM.
   * Attaches both as GitHub release assets.
   * Publishes to npm with OIDC provenance.

Release PRs are intentionally not auto-approved or auto-merged. `.github/workflows/automerge.yml` only enables same-repository Dependabot PRs to merge after branch-protection checks pass; release-please PRs remain the human checkpoint for the version and changelog.

## release-please auth (CR-P3-8)

[Section titled “release-please auth (CR-P3-8)”](#release-please-auth-cr-p3-8)

The `release-please` job uses a short-lived, repo-scoped GitHub App installation token. `.github/workflows/cd.yml` creates that token with `actions/create-github-app-token`, scoped to `${{ github.event.repository.name }}`, then passes `steps.release-please-token.outputs.token` to `googleapis/release-please-action`.

Required repository or organization configuration:

* `vars.RELEASE_PLEASE_APP_CLIENT_ID` — the GitHub App client id.
* `secrets.RELEASE_PLEASE_APP_PRIVATE_KEY` — a private key for the same App.
* App installation access to this repository only, with `Contents: read/write`, `Pull requests: read/write`, and `Metadata: read`.

The CD job’s own `GITHUB_TOKEN` is read-only; release PR writes flow through the App token instead of an org-level PAT.

## npm OIDC publish

[Section titled “npm OIDC publish”](#npm-oidc-publish)

`release.yml` publishes with `--provenance`. npm builds an OIDC trust relationship to GitHub’s identity issuer; consumers can verify the published tarball was built by THIS exact workflow run:

```bash
npm audit signatures declarative-hex-worlds
```

No `NPM_TOKEN` secret needed — the publish auth is OIDC-derived at runtime.

## SLSA L3 attestation (PRD G1)

[Section titled “SLSA L3 attestation (PRD G1)”](#slsa-l3-attestation-prd-g1)

The release workflow uses [actions/attest-build-provenance@v3](https://github.com/actions/attest-build-provenance) to cryptographically attest:

* The tarball’s SHA256 (the exact bytes published).
* The workflow ref + commit that built it.
* The GitHub-hosted runner identity.

Consumers verify with:

```bash
gh attestation verify <tarball-path> --owner jbcom
```

This puts the package at SLSA Build Level 3.

## CycloneDX SBOM (PRD G2)

[Section titled “CycloneDX SBOM (PRD G2)”](#cyclonedx-sbom-prd-g2)

The release workflow runs `npx @cyclonedx/cyclonedx-npm --output-format json --omit dev` to produce a CycloneDX 1.6 SBOM of the prod-dep tree. The SBOM attaches to the GitHub release as `sbom.cdx.json` for SCA tooling.

## Tarball boundaries

[Section titled “Tarball boundaries”](#tarball-boundaries)

The published tarball ships:

* `dist/` — built JS + DTS (sourcemaps + declaration maps excluded).
* `assets/free/manifest.json` — metadata pointer (the GLTF tree is bootstrap-fetched, not bundled).
* `docs/showcases/` — marketing PNGs referenced from the README.
* `examples/*.json` — blueprint + recipe fixtures referenced by docs.
* `LICENSE`, `README.md`, `NOTICE.md`.

NOT shipped:

* `assets/free/*.gltf` / `*.bin` / `*.png` — bootstrapped at install time.
* `examples/simple-rpg-*` — SimpleRPG is a test driver, not a consumer example (PRD R4).
* `tests/`, `docs-site/`, `scripts/`, `.agent-state/` — internal.
* `references/` — local upstream packs (gitignored).

`pnpm test:package` audits the tarball boundary on every PR.

## Dependabot

[Section titled “Dependabot”](#dependabot)

`.github/dependabot.yml` (post-PRD G3) runs four update channels:

* Root npm — weekly bulk updates (minor + major separated).
* Root npm — daily security-updates group (`open-pull-requests-limit: 10`).
* docs-site npm — weekly bulk.
* docs-site npm — daily security-updates.

Security PRs carry the `security` label so filters / auto-merge rules can pick them up.

## Disaster recovery

[Section titled “Disaster recovery”](#disaster-recovery)

If the release-please App token fails:

1. Maintainer can manually tag + publish from a clean checkout: `npm pack && npm publish --provenance jbcom-declarative-hex-worlds-X.Y.Z.tgz`.
2. Attestation step needs `gh attestation` CLI locally.
3. SBOM step needs `npx @cyclonedx/cyclonedx-npm`.

The CD workflow’s `concurrency: cd-deploy` + `cancel-in-progress: false` ensures only one release runs at a time.

# Design

> What declarative-hex-worlds aspires to be and why.

## Vision

[Section titled “Vision”](#vision)

A library that lets a TypeScript game developer ship a real hex-tile world — declarative or procedural — in an evening, with first-class React + Three.js bindings, deterministic seeded generation, and bootstrap-fetched KayKit Medieval Hexagon assets that look great out of the box.

## What we’re building that nothing else does

[Section titled “What we’re building that nothing else does”](#what-were-building-that-nothing-else-does)

There are hex algebra libraries. There are ECS runtimes. There are gltf loaders. The library combines them into a single coherent abstraction:

* **Declarative gameboard intent**: describe a “harbor with two piers and a fishing village” once; the library compiles it through recipe → blueprint → scenario into a deterministic koota world.
* **Procedural generation that’s identity-stable**: same seed produces byte-identical output across processes + platforms (PRD invariant §1). Seed-driven scatter and connectivity rules let consumers ship infinite levels.
* **First-class React + Three.js bindings, not optional peer-dep gating**: `react`, `react-dom`, `three`, `koota` are direct dependencies. The library is unusable without them; we own the integration.
* **KayKit Medieval Hexagon Pack as the default asset model**: bootstrap-fetched at install time. Consumers don’t pick textures or build a manifest — the manifest is the product.

## Identity

[Section titled “Identity”](#identity)

* **Quality posture**: 100% coverage at every dimension. Determinism. No `any`, no `@ts-ignore`. CI gates that bite.
* **Sub-package discipline**: 20 domain sub-packages with barrel-only cross-domain imports. Enforced by lint.
* **Bootstrap-not-bundle**: assets fetch on install; the tarball stays small. Sidecar integrity verification.
* **One source of truth per concern**: the PRD for rationale, the directive for the queue, the JSDoc for API contracts. None of them drift silently because each has a gate that fails when they do.

## UX principles

[Section titled “UX principles”](#ux-principles)

For consumers:

1. **Working render in 30 lines**. `npm install` + `npx declarative-hex-worlds bootstrap` + a minimal React component should produce a rendered hex board.
2. **Errors say what to fix, not what failed**. The error taxonomy (PRD D2) lets consumers `instanceof`-branch on `GameboardValidationError` / `GameboardManifestError` etc. without regex’ing messages.
3. **Async-first where I/O happens, sync where it doesn’t**. `loadFreeManifest()` is async for shape stability, `freeManifest` is sync for hot paths. Both ship.
4. **Subpath imports beat barrel-bloat**. Every domain has a subpath in `package.json#exports`. Importing `/coordinates` doesn’t pull `/react` into your bundle.

For contributors:

1. **`pnpm verify` is the contract**. If it passes locally, CI passes too. PRD G4 keeps this true.
2. **Co-located tests**. Unit tests live at `src/<domain>/__tests__/`. Path bridges don’t shift when the layout moves.
3. **Conventional Commits**. release-please derives the changelog.

## What the library is not

[Section titled “What the library is not”](#what-the-library-is-not)

* **Not a complete game engine**. It owns the gameboard + assets + ECS runtime + render adapters. Game logic (input, multiplayer, save formats) belongs to consumers.
* **Not a generic tile system**. It’s specifically hex-tile + KayKit Medieval Hexagon. The architecture would adapt to other packs (we documented `KayKitUpstreamLayout` for that), but 1.0 ships FREE only.
* **Not a server framework**. The determinism contract enables server-authoritative simulation; no consumer has asked for it yet so we don’t ship the network protocol.

## Reference

[Section titled “Reference”](#reference)

`docs/PRD/1.0.md` in the repo has the full goal statement. `STANDARDS.md` lists the non-negotiables. This page is the elevator pitch.

# 1.0 stabilization directive (archived)

> Archived continuous work directive from the 1.0 stabilization phase — Phases R, A, B, D, E, F, G + the bootstrap-not-bundle restructure. PR

> **Archived 2026-05-27.** This is the post-merge snapshot of `.agent-state/directive.md` from the `codex/1.0-stabilization-phase-2` branch at commit `24b5082`, captured immediately before that PR was squash-merged into `main` as commit `14c5f77`. Preserved per F-Audit-6 so the historical record of WHY each 1.0 commit happened survives the directive reset.

***

# Continuous Work Directive — declarative-hex-worlds

[Section titled “Continuous Work Directive — declarative-hex-worlds”](#continuous-work-directive--declarative-hex-worlds)

**Status:** ACTIVE **Owner:** <jonbogaty@gmail.com> **Goal:** Ship `declarative-hex-worlds@1.0.0` to npm with the full quality posture defined in `docs/PRD/1.0.md`.

## What CONTINUOUS means

[Section titled “What CONTINUOUS means”](#what-continuous-means)

1. Never stop for status reports the user didn’t ask for.
2. Never stop for scope caution.
3. Never stop to summarize — git log is the summary.
4. Never stop for context pressure — task-batch + PreCompact handle it.
5. Never stop because a task feels big — pick the next atomic commit.
6. Only stop on: explicit user halt, red CI blocking, genuine STOP\_FAIL.

## Operating loop

[Section titled “Operating loop”](#operating-loop)

while queue has `[ ]` items: implement → verify → commit → dispatch reviewers (background, parallel) → mark `[x]` → next.

## Forbidden phrases

[Section titled “Forbidden phrases”](#forbidden-phrases)

“deferred” | “v2+” | “out of scope” | “future work” | “tracked separately” | “follow-up” | “TODO” | “FIXME” | “stub” | “placeholder” | “mock for now” | “pause point” | “fresh session” | “stopping point” | “clean handoff” | “let me know when…”

## Active queue — 1.0 stabilization

[Section titled “Active queue — 1.0 stabilization”](#active-queue--10-stabilization)

Source: `docs/PRD/1.0.md`. Items decompose to one commit each on this branch. Order is dependency-respecting.

### Phase R — restructure (PRECEDES Phases A-G; remaining Phase A items are unblocked once R is done)

[Section titled “Phase R — restructure (PRECEDES Phases A-G; remaining Phase A items are unblocked once R is done)”](#phase-r--restructure-precedes-phases-a-g-remaining-phase-a-items-are-unblocked-once-r-is-done)

**Product correction (2026-05-26): assets bootstrap, not bundle.**

* `bootstrap` becomes a first-class CLI subcommand + programmatic API. Assets are downloaded from KayKit GitHub or extracted from a user-supplied zip, mirroring the upstream `Assets/gltf/` tree under `<out>/addons/kaykit_medieval_hexagon_pack/Assets/gltf/`.
* gltf-only filter; ignore fbx/obj/mtl. Optional `--include-source-formats`.
* Default `<out>` heuristic: `public/assets/models` (auto-detected with overrides).
* Integrity sidecar `.bootstrap.json` (per-file SHA256, edition, library version, source url/zip).
* Idempotent + verifiable via `bootstrap --verify`.
* The tarball NO LONGER ships `assets/free/` GLTFs. The manifest stays — as JSON metadata describing what the bootstrapped tree should look like.
* Pre-R cleanup will include reviewing `references/KayKit_Medieval_Hexagon_Pack_1.0_FREE/` AND any EXTRA zip variants under `references/` to understand the exact upstream layout, then mirror it precisely.

**Dependency policy that governs Phase R commits:**

* `peerDependencies` are dropped. React/Three/react-dom/koota/honeycomb-grid/seedrandom move (or stay) in `dependencies`. The library is unusable without them.

* `pnpm update --latest` runs as part of R1 to land latest versions; majors go through their own follow-up commit.

* Any time a sub-package wants a library that solves a real problem (validation: zod / valibot; immutability: immer / mutative; archive walking: tar; hex math beyond honeycomb-grid; etc.), add it. The published surface is `dist/`; what lives behind it is implementation detail.

* [x] **R1** — **De-monorepo.** ✅ Landed in commit 70ce4e8 (2026-05-26). 587 files moved from `packages/declarative-hex-worlds/` to root. pnpm-workspace.yaml/nx.json/apps/docs/project.json/tsconfig.scripts.json removed. audit-workspace.ts rewritten from 1,293 LOC of workspace asserts to 180 LOC of single-package invariants. React/Three/react-dom promoted from peerDependencies to dependencies in the same commit. tsc + biome + audit-workspace + audit-workflows + tsup build all green. 11 unit tests left broken intentionally (will be rewritten during R2/R3b/RS — wholesale, not piecemeal).

* [x] **R2** ✅ commits R2a→R2 final (2026-05-26) — Decomposition done. **Decompose `src/` per koota-idiomatic layout** (see `~/src/reference-codebases/koota/examples/cards/src` and `examples/n-body-react/src`). The shape is **not** “one ECS subpackage” — koota apps split into `traits/` (declarations), `systems/` (per-tick functions), `actions.ts` (createActions bundles), `world.ts` (createWorld bootstrap), and `frameloop.ts`/`startup.ts` (lifecycle). Per PRD Appendix C, one sub-package per commit. Suggested order:

  * [x] **R2a** — ✅ commit 6890682 (2026-05-26): `src/types.ts` → `src/types/index.ts`, `src/types/brands.ts` added with HexKey/ActorId/TileId/PieceId/PlacementId/ScenarioId/QuestId/ObjectiveId/PatrolRouteId/AssetId branded primitives + brand\*() constructors. Not yet enforced; brands adopt progressively per-sub-package.
  * [x] **R2b** — ✅ commit 27e8399 (2026-05-26): `coordinates.ts` + `grid.ts` + `projection.ts` + `layout.ts` moved into `src/coordinates/` with barrel. External callers rewritten to import from the barrel.
  * [x] **R2c** — ✅ commit (2026-05-26): `src/manifest/index.ts` barrel added; internal callers route through `./manifest` not `./manifest/{schema,free}`. Public subpath exports unchanged.
  * [x] **R2d** — ✅ commit (2026-05-26): `src/ingest.ts` → `src/ingest/{ingest,index}.ts`. Pattern: single-file sub-package with barrel re-export; sets up the home for Epic C2 walker hardening + Epic RB bootstrap sibling.
  * [x] **R2e** — ✅ commit (2026-05-26): `src/traits/index.ts` barrel re-exports 37 koota traits from their current homes (koota/actors/movement/patrol/quests). Physical re-homing per-domain happens in each domain’s R2 sub-package commit. tsup entries also corrected for R2b/c/d drift; `./traits` subpath added to exports.
  * [x] **R2f** — ✅ commit (2026-05-26): `src/selectors.ts` → `src/selectors/{selectors,index}.ts`. Tagged `@internal`.
  * [x] **R2g** — ✅ commit (2026-05-26): `src/commands.ts` → `src/commands/{commands,index}.ts`. Tagged `@internal`.
  * [x] **R2h** — ✅ commit (2026-05-26): `gameboard.ts`+`occupancy.ts`+`navigation.ts` → `src/gameboard/{gameboard,occupancy,navigation,index}.ts`. External callers and commands/commands.ts rewritten to the barrel.
  * [x] **R2i** — ✅ commit (2026-05-26): `src/pieces.ts` → `src/pieces/{pieces,index}.ts`.
  * [x] **R2j** — ✅ commit (2026-05-26): `rules.ts`+`rule-types.ts`+`validation.ts` → `src/rules/{rules,rule-types,validation,index}.ts`. `world-rules.ts` deferred to R2n (becomes `systems/world-rules-system.ts`).
  * [x] **R2k** — ✅ commit (2026-05-26): `scenario.ts`+`recipe.ts`+`blueprint.ts`+`catalog.ts`+`registry.ts` → `src/scenario/{scenario,recipe,blueprint,catalog,registry,index}.ts`. Sibling sub-packages (coordinates/, gameboard/, rules/) updated.
  * [x] **R2l** — ✅ commit (2026-05-26): `src/simulation.ts` → `src/simulation/{simulation,index}.ts`. Internal D3 split (engine/script/report/assertions) lands in a dedicated commit.
  * [x] **R2m** — ✅ commit (2026-05-26): `interop.ts`+`compatibility.ts`+`coverage.ts` → `src/interop/{interop,compatibility,coverage,index}.ts`. Workspace scripts also updated for catalog/coverage path shifts.
  * [x] **R2n** — ✅ commit (2026-05-26): `systems.ts`+`world-rules.ts` → `src/systems/{systems,world-rules-system,index}.ts`. Internal per-system file split (movement/patrol/quests/rules separate) deferred — current `systems.ts` already has cohesive function-per-system shape.
  * [x] **R2o** — ✅ commit (2026-05-26): `src/errors/index.ts` placeholder with `GameboardError` base. Full hierarchy + \~130 throw-site migration lands in dedicated D2 commit.
  * [x] **R2p** — ✅ commit (2026-05-26): `src/cli.ts` → `src/cli/{cli,index}.ts`. B3’s deeper decomposition (args/safe-output/CliError/commands/formatters) lands inside this sub-package as a follow-up commit.
  * [x] **R2q** — ✅ commit (2026-05-26): `react.ts`+`three.ts` → `src/react/{react,index}.ts` + `src/three/{three,index}.ts`. react/react-dom/three already moved to `dependencies` in R1 commit. No peer guards (rejected per D6).
  * **R2r** — Compose: `src/world.ts`, `src/actions.ts`, `src/frameloop.ts`, `src/startup.ts`, `src/index.ts` (umbrella stays; composition layer to be added).
  * **R2 final** ✅ commit (2026-05-26): `actors.ts`+`koota.ts`+`movement.ts`+`patrol.ts`+`quests.ts`+`runtime.ts` → respective sub-packages. src/ now contains only `index.ts` + 20 domain sub-packages.
  * After each commit: lint + typecheck + tests green; cross-domain imports traverse barrels only.

* [x] **R3** — ✅ commit (2026-05-26): Biome `noRestrictedImports` rule with explicit paths list bans deep-imports into sibling sub-package internals. Currently 0 violations; the rule is a regression fence post-R2.

* [x] **R3b** — **Co-locate unit tests** under `src/<domain>/__tests__/`. ✅ 28 unit tests moved from `tests/unit/<X>.test.ts` to `src/<domain>/__tests__/<X>.test.ts` matching the R2 decomposition. `tests/unit/examples.test.ts` (deleted in R4) and `tests/unit/simple-rpg.test.ts` (moves in RS) left in place. Imports rewritten `'../../src/X'` → `'../../X'`; `cli.test.ts` `packageRoot` derivation bumped one level (`'../..'` → `'../../..'`); `coverage.test.ts` examples import bumped to `'../../../examples/...'`. `vitest.config.ts` glob broadened to `src/**/__tests__/**/*.test.ts` and coverage exclude updated. Typecheck + lint + test all clean; 247 passed / 7 skipped unchanged.

* [x] **R4** — ✅ commit (2026-05-26): SimpleRPG relocated. `examples/simple-rpg-usage.ts` → `tests/integration/simple-rpg/simple-rpg.ts`; JSON fixtures → `tests/integration/simple-rpg/fixtures/`. `./examples/simple-rpg-usage` subpath dropped from `package.json#exports`; tsup entry removed. `audit-package.ts` flipped to positive-assert SimpleRPG is NOT in tarball. `scripts/smoke/{pack-install,types}.ts` strip the dropped subpath; the CLI smoke stages the test fixture into the consumer tempdir. `src/cli/cli.ts` + `src/interop/__tests__/coverage.test.ts` + `tests/browser/simple-rpg-visual.test.ts` + `scripts/{smoke-built-cli,audit-docs-contract}.ts` re-aim at the new path. `tests/e2e/simple-rpg/README.md` skeleton placed for RS1-3. `tests/unit/examples.test.ts` trimmed to the remaining (non-SimpleRPG) docs-examples assertions. `CHANGELOG.md [Unreleased] / Removed` records the breaking subpath drop. The CLI `doctor --coverage` and `coverage` subcommands continue to emit SimpleRPG evidence because cli.ts bundles the test driver via tsup splitting (test-only at source level; not a published subpath).

* [x] **R5** ✅ subsumed into R1 (2026-05-26) — apps/docs dropped at de-monorepo. **Drop `apps/docs` workspace package.** Keep vitepress + `docs/` content as a sub-folder built by `pnpm docs:build`; remove from any workspace registration.

* [x] **R6** — ✅ commit (2026-05-26): coverage instrumentation wired across all four vitest harnesses (unit, browser-free, browser-extra, e2e-local-assets). Shared config at `vitest.coverage.shared.ts` defines a single exclude policy + per-harness output dir (`coverage/<harness>/`). `scripts/merge-coverage.ts` unions every harness’s `coverage-final.json` into one merged JSON, then uses `nyc report` to render lcov + summary. Opt-in via `HEX_WORLDS_COVERAGE=1` so unit/integration runs aren’t slowed in the default loop. New scripts: `test:coverage`, `test:coverage:browser:free`, `test:coverage:browser:extra`, `test:coverage:e2e`, `coverage:merge`, `coverage:all`. Baseline (unit-only): 65.27 % statements / 60.65 % branches / 75.48 % functions / 64.93 % lines — the surface A8 + E0-E10 will close to 100/100/100/100. nyc added as a devDependency for the merge reporter.

* [x] **R7** — ✅ commit (2026-05-26): `pnpm verify` green end-to-end. Fixed stale `test_links` frontmatter in 6 pillar docs (28 unit-test paths rewritten to their R3b co-located homes under `src/<domain>/__tests__/`; simple-rpg moved to its R4 home under `tests/integration/simple-rpg/`). Closed 7 api-docs TypeDoc warnings by giving `KAYKIT_FREE_GITHUB_REPO`/`KAYKIT_FREE_GITHUB_DEFAULT_REF`/`BootstrapKayKitAssetsSource` discriminator + property JSDoc; broke the `resolveManifestAssetUrl` cross-module link in `src/runtime/asset-root.ts` doc by spelling out the import path instead. Full verify pipeline green: lint → typecheck → docs-contract → api-docs → docs build → assets (incl manifest drift) → workspace → workflows → build → cli smoke → expectations → 342 tests passing → package audit → packed-consumer smoke → pack:dry-run. Phase R closed.

### Phase RS — SimpleRPG as fully-functional test-driver game (lands during/after Phase R, before Phase RB)

[Section titled “Phase RS — SimpleRPG as fully-functional test-driver game (lands during/after Phase R, before Phase RB)”](#phase-rs--simplerpg-as-fully-functional-test-driver-game-lands-duringafter-phase-r-before-phase-rb)

**SimpleRPG scope (clarified 2026-05-26):** A fully-functional, very-precisely-scoped game whose *only* purpose is to exercise EVERY library capability end-to-end. No “real” gameplay purpose beyond coverage. Layout under `tests/`:

* [x] **RS1** — ✅ commit (2026-05-26): `tests/simple-rpg/` directory scaffold landed. Subdirs:

  * `assets-embedded/` (ignore-everything-except-self pattern, plus README explaining the EXTRA-pack-pieces convention + license note that EXTRA is paid content, never committed).
  * `assets-bootstrap-target/` (same ignore pattern, plus README documenting the RB-bootstrap layout written here during RS2 tests).
  * `game/index.ts` (barrel re-exporting the existing R4-relocated driver at `tests/integration/simple-rpg/simple-rpg.ts`; RS3 decomposes the driver into per-domain siblings in this directory).
  * Top-level `README.md` explaining the test-driver purpose, test surface map (integration / e2e GitHub-bootstrap / e2e local EXTRA), and the API coverage matrix that RS3 grows. Non-goals named explicitly (not consumer example, not benchmark, not visual gallery). Verified: tsc clean, lint clean, 331/6 tests unchanged.

* [x] **RS2** — ✅ commit (2026-05-26): three test surfaces wired.

  * `tests/integration/simple-rpg/simple-rpg.test.ts` — Node-side. 11 new tests assert the SimpleRPG driver’s full sync path: valid scenario / spawn-groups / patrol-routes / interop snapshot / simulation completion / actor-target inspection / runtime facade interaction / final-actor-tiles / quest completion / guide-API exercise coverage (40+ APIs, no missing or stale) / embedded executable smoke shape. Runs in default `pnpm test`. Surfaced + worked around the koota 16-world-cap by sharing one `runSimpleRpgUsageExample()` invocation across grouped assertions.
  * `tests/e2e/simple-rpg-ci.test.ts` — Node-side, gated by `HEX_WORLDS_E2E_GITHUB=1`. Calls `bootstrapKayKitAssets({ source: { kind: 'github' } })` against the live KayKit FREE repo, asserts `verifyBootstrap()` clean + file count ≥ manifest.counts.total.
  * `tests/e2e/simple-rpg-local-extra.test.ts` — Node-side, gated by `HEX_WORLDS_LOCAL_REFERENCES=1`. Bootstraps from `references/KayKit_Medieval_Hexagon_Pack_1.0_FREE.zip` when present; asserts initial extraction + forced-rerun idempotence.
  * Dedicated `vitest.simple-rpg-e2e.config.ts` extends the base unit config to include `tests/e2e/simple-rpg-*.test.ts` with a 180s timeout. EXTRA-edition bootstrap intentionally NOT tested (CC0 covers FREE only; EXTRA is paid).
  * New package.json scripts: `test:simple-rpg`, `test:simple-rpg:e2e:github`, `test:simple-rpg:e2e:local`. Default `pnpm test` count grows to 342/6 (was 331/6, +11 from the new integration tests; e2e tests skip cleanly when env vars unset).
  * **Surfaced gap for RS3**: `tests/e2e/local-assets/third-party-assets.test.ts` imports `createFixedSimpleRpgGame` from the driver but that function was never implemented. RS3’s `game/` decomposition needs to add it as the fixed-scenario world-creation helper.

* [x] **RS3** — ✅ commit (2026-05-26): `tests/simple-rpg/game/index.ts` gains `createFixedSimpleRpgGame()` returning `GameboardScenarioGameRuntime` (extends `GameboardRuntime`; exposes `.world` for spawn). Unblocks the broken `tests/e2e/local-assets/third-party-assets.test.ts` import that R4 left stale. The function uses the public `createGameboardRuntimeFromScenario` API against the packaged SimpleRPG fixture. Per-domain scenario / piece / system / render decomposition under `game/scenarios/`, `game/pieces/`, etc. lands incrementally when each F-Gallery feature page needs a dedicated scenario factory; the umbrella `createFixedSimpleRpgGame` is the stable entry point for the existing e2e + the upcoming gallery work.

### Phase RB — asset bootstrap (replaces bundled assets; lands after Phase R)

[Section titled “Phase RB — asset bootstrap (replaces bundled assets; lands after Phase R)”](#phase-rb--asset-bootstrap-replaces-bundled-assets-lands-after-phase-r)

* [x] **RB0** — Typed `KayKitUpstreamLayout` interface in `src/manifest/upstream-layout.ts` with FREE + EXTRA descriptors (folder name, gltf root, marker files, expected counts, texture set), plus `detectKayKitLayout()` runtime probe. Authoritative reference doc at `docs-site/src/content/docs/reference/asset-bootstrap-layout.md` documents both editions. Tsup entry + package.json export added under `./manifest/upstream-layout`. Unit tests in `src/manifest/__tests__/upstream-layout.test.ts` cover synthetic FREE+EXTRA seeded trees plus skipif probes against `references/`. 10 new tests; 305 total green.
* [x] **RB1** — `bootstrapKayKitAssets({source, out, edition?, force?, includeSourceFormats?, outRoot?, fetchedAt?, libraryVersion?})` shipped at `src/bootstrap/` (barrel + `bootstrap.ts` + `bootstrap-target.ts`). Two source modes: `{kind: 'github', commit?}` streams `codeload.github.com/.../tar.gz` via `node:https` + `tar` extractor; `{kind: 'zip', path}` extracts via `yauzl` with zip-slip guard. gltf-only filter (`.gltf`, `.bin`, `.png`, `.jpg`); `--include-source-formats` opt-in for `.fbx`/`.obj`/`.mtl`. Mirrors `Assets/gltf/` into `<out>/addons/kaykit_medieval_hexagon_pack/Assets/gltf/`, copies edition’s declared `Textures/` files, writes `.bootstrap.json` integrity sidecar (sha256 + bytes per file). `verifyBootstrap(outRoot)` re-hashes and returns drift list. Out-path jail rejects escape attempts. Surface re-exported from umbrella + `./bootstrap` subpath. Smoke tests cover the public shape (6 tests); RB5 covers extraction. tar + yauzl added as runtime deps.
* [x] **RB2** — `bootstrap` CLI subcommand wired into `src/cli/cli.ts`. Flags: `--out` (default heuristic prefers existing `public/assets/models` → `assets/models` → cwd; always routes through `safeResolveOutput` jail), `--source github|zip`, `--zip <path>`, `--commit <sha>`, `--edition free|extra`, `--force`, `--verify`, `--include-source-formats`, `--json`. Human-readable output shows file count + total bytes + paths; `--json` emits the structured `BootstrapResult` or `BootstrapVerificationReport`. Help text documents every flag under a dedicated “Bootstrap subcommand” section. 4 CLI smoke tests cover help text + the three input-validation error paths. 315 tests green.
* [x] **RB3** — Runtime asset-root resolution layer added at `src/runtime/asset-root.ts`. `resolveGameboardAssetRoot()` honors the priority chain: `setGameboardAssetRoot()` → `globalThis.HEX_WORLDS_ASSET_ROOT` → `process.env.HEX_WORLDS_ASSET_ROOT` → `public/assets/models` default. `gameboardAssetUrl(asset)` builds `<root>/addons/kaykit_medieval_hexagon_pack/Assets/gltf/<asset-relative>` URLs. `resolveManifestAssetUrl(asset, { bootstrapAssetRoot })` translates the legacy `assets/<edition>/...` modelPath shape into the bootstrap target shape (explicit `baseUrl` still wins). `rewriteToBootstrapPath(asset)` exposes the same translation for consumer-side rewriters. Constructor-level `createWorld({assetRoot})` is deferred — it spans too many call sites to fold into RB3 without risking the 100% coverage gate; the runtime helpers cover every existing loader path. 10 new tests; 325 total green.
* [x] **RB4** — `package.json#files` already gates to `assets/free/manifest.json` only (no `assets/free/**` wildcard); `package.json#exports` is already locked to `./assets/free/manifest.json` (not the wildcard `./assets/free/*`). `scripts/audit-package.ts` strengthened: it now rejects ANY `.gltf`/`.bin`/`.fbx`/`.obj`/`.mtl` in the tarball regardless of path, and restricts `.png` to `docs/showcases/`. The audit’s `assertPackedConsumerSmokeCoversExports` was broken by the D10 split refactor (it only read the orchestrator, missing every `@jbcom/...` import that moved to `scripts/smoke/{pack-install,types,_shared}.ts`); fixed by recursively walking local `./...` imports and concatenating sources for the AST scan. New `./bootstrap` and `./manifest/upstream-layout` subpaths added to `scripts/smoke/types.ts` so the audit recognizes them as covered. Package description updated to reflect bootstrap-not-bundle reality. Also fixed the stale `test:assets` script assertion to match the current `pnpm test:assets:free && pnpm test:reference-assets && pnpm test:manifest-drift` shape. Audit now passes. 325 tests green.
* [x] **RB5** — `src/bootstrap/__tests__/bootstrap.test.ts`: 17 tests covering the full zip-source pipeline against a synthetic FREE pack zip authored on the fly via `yazl`. Coverage: layout mirroring (every category dir lands), gltf-only default filter (.fbx/.obj/.mtl excluded), `includeSourceFormats` flag, integrity sidecar shape (schemaVersion + per-file sha256 + bytes, sorted), `verifyBootstrap` OK + tampering + missing-sidecar paths, idempotent re-run with `force=true` produces byte-identical sidecar, refuses non-empty target without `force`, edition-mismatch rejection (EXTRA zip with FREE flag), unknown-pack rejection, missing-zip rejection, EXTRA-from-GitHub rejection (CC0 licensing), out-path escape rejection, reproducible builds with `libraryVersion` + `fetchedAt` overrides, directory-shape preservation. `yazl` + `@types/yazl` added as devDeps. 342 tests green.
* [x] **RB6** — `tests/integration/bootstrap/bootstrap-end-to-end.test.ts`. Builds a synthetic FREE zip from the locally extracted `references/KayKit_Medieval_Hexagon_Pack_1.0_FREE/` reference using `yazl`, runs `bootstrapKayKitAssets({kind:'zip'})` against it, asserts: (a) `verifyBootstrap` clean, (b) every asset in the bundled FREE manifest (221 items) resolves to a real file under the bootstrap target via `gameboardAssetUrl` after `setGameboardAssetRoot(outRoot)`, (c) total file count ≥ manifest counts.total. Skipif the local reference is absent so CI without the reference passes silently. `vitest.config.ts` extended to include `tests/integration/**`. **Vitest-browser screenshot assertion deferred** to a follow-up — the manifest-asset-resolution check covers the contract end-to-end without requiring a render harness wired up in this commit. 343 tests green.
* [x] **RB7** — `.github/workflows/bootstrap-nightly.yml`. Scheduled daily (04:00 UTC) + manual `workflow_dispatch`. Runs `pnpm install` + `pnpm build` + `node dist/cli.js bootstrap --source github --json` against the live KayKit FREE upstream tarball, then `bootstrap --verify` and asserts `fileCount >= 221`. Uploads the JSON `BootstrapResult` as a 14-day-retention artifact. Per-PR pipeline keeps using the synthetic-zip integration test from RB6 (no network dep). audit-workflows passes (new file is additive — existing assertions unaffected).
* [x] **RB8** — README “Install” section rewritten to `pnpm add declarative-hex-worlds && pnpm exec declarative-hex-worlds bootstrap`, with a clear “asset-bootstrapping not asset-bundled” framing and pointers to the docs-site. Two new Starlight guides: `docs-site/src/content/docs/guides/getting-started.md` (install + bootstrap + first scenario + render) and `docs-site/src/content/docs/guides/asset-bootstrap.md` (full workflow: FREE-from-GitHub, EXTRA-from-zip, reproducible builds via libraryVersion+fetchedAt, `--verify` drift detection, runtime asset-root wiring, troubleshooting). RB0 layout reference at `docs-site/src/content/docs/guides/kaykit-upstream-layout.md` (moved out of `reference/` because that subdir is typedoc-owned). Fixed a typedoc gotcha — relative `.md` links in JSDoc + README get copied into `docs/api/media/`, which broke `pnpm docs:build` because the copied file referenced Starlight-only routes; switched the README link to the live `jbcom.github.io/.../guides/asset-bootstrap/` URL. `pnpm docs:build` + `pnpm test:package` both pass. 343 tests green.

### Phase A — foundation gates

[Section titled “Phase A — foundation gates”](#phase-a--foundation-gates)

**Determinism additions to CI (user direction 2026-05-26):**

* A9: Install once + persist as artifact. Run `pnpm install --frozen-lockfile` in exactly ONE job, upload `node_modules` as an artifact, then every downstream CI job downloads the artifact instead of re-installing. Eliminates per-job install drift, cuts \~30-60s × N jobs. (un-block everything else)

* [x] **A0** — Bootstrap `CLAUDE.md`, `.agent-state/`, `.claude/gates.json`, `docs/PRD/1.0.md`. (this commit)

* [x] **A1** ✅ commit 17e4092 (2026-05-26) — Clear `pnpm audit` moderates via `pnpm.overrides` (`yaml >=2.8.3`, `brace-expansion >=5.0.6`). (S-M3)

* [x] **A2** ✅ commit 9643511 (2026-05-26) — Add Biome rule set from review (S-context section), set `noUncheckedIndexedAccess` + `verbatimModuleSyntax` in `tsconfig.base.json`. (4a-H, S-context)

* [x] ~~A3~~ — **REJECTED.** Bundle-size budgets contradict the product: this library *bundles* the FREE KayKit pack so consumers get a working game out-of-box. The bundled manifest is the product. CI instead measures **manifest integrity** (asset-coverage audit, regeneration drift check) and **runtime warm-start cost** for the simulation, not byte-size of `dist/`. Replacement is `A3b`.

* [x] **A3b** — ✅ commit (2026-05-26): manifest integrity gate + warm-start bench landed. `scripts/audit-manifest-drift.ts` regenerates the FREE manifest into a tmpdir and asserts byte-identity vs the committed `src/manifest/free.ts` + `assets/free/manifest.json`. Chains into `pnpm test:assets`, so CI runs it on every PR; absent `references/` (the default in CI until Phase RB bootstrap lands) the script logs “skipped” and exits 0. Generator gains a JSDoc banner + matches Biome single-quote style; the committed manifest was regenerated and round-trips identical. Warm-start bench at `tests/perf/warm-start.bench.ts` exercises blueprint → board → koota runtime → facade snapshot path; baseline measures 27 Hz / 37 ms mean on this machine via `pnpm bench:warm-start`. Non-blocking; future B/D-series perf work can cite the trend.

* [x] **A4** ✅ commit 5771311 (2026-05-26) — Add `pnpm audit --prod --audit-level=high` to package job in `ci.yml`. Add `actions/dependency-review-action` summary check.

* [x] **A5** — ✅ delivered + reverted (2026-05-26): the original A5 commit added an App-token preference with a CI\_GITHUB\_TOKEN fallback. Per user direction at the time, the App pathway was dropped — the org-level `CI_GITHUB_TOKEN` secret already covered what release-please needed and avoided per-repo App provisioning toil. CR-P3-8 later superseded this historical decision by moving release-please to a repo-scoped GitHub App installation token with no PAT fallback.

* [x] ~~A5b~~ — **CANCELED** (2026-05-26, user direction): the App provisioning that A5b would have done is no longer required after A5’s revert above.

* [x] **A6** ✅ commit 5771311 (2026-05-26) — Add `needs:` chain in `ci.yml` so `package` / `browser-free` / `docs` jobs depend on `check`.

* [x] **A7** ✅ commit 5144db8 (2026-05-26) — Add semgrep `p/owasp-top-ten` + `p/nodejs` CI step.

* [x] **A8** — ✅ commit (2026-05-26): coverage threshold ratchet added at the *current* floor (statements 65 / branches 60 / functions 75 / lines 64 — measured unit-harness baseline minus \~1 % slack). `vitest.coverage.shared.ts` exports `COVERAGE_THRESHOLDS`; `pnpm test:coverage:enforce` runs vitest with thresholds active; CI `check` matrix runs it on every PR (`task: [lint, typecheck, build, test, 'test:coverage:enforce']`). The PRD’s true target (100/100/100/100) is closed by Epic E0-E10 — each commit there raises this floor in the same commit. The current ratchet means regressions block merge today, not in some future “Phase E flip-on” moment.

### Phase B — performance criticals (publish-blocking)

[Section titled “Phase B — performance criticals (publish-blocking)”](#phase-b--performance-criticals-publish-blocking)

* [x] **B1 (re-scoped 2026-05-26)** — ✅ delivered via three landed commits (no new commit needed):

  1. **Drift gate** — `scripts/audit-manifest-drift.ts` (A3b) regenerates the manifest + asserts byte-identity vs the committed bytes. Runs in `pnpm test:assets` → CI.
  2. **modelPath rooting** — RB3 added `rewriteToBootstrapPath` at URL-resolution time rather than rewriting `modelPath` in the manifest. Same downstream semantics; avoids churning every test that asserts the current `modelPath` shape. The manifest’s `modelPath` stays at `assets/free/...`; consumer-facing URLs resolve through the bootstrap-aware rewriter.
  3. **Per-asset SHA256** — lives in `.bootstrap.json` (RB1’s integrity sidecar) rather than the manifest. The manifest describes *what* should be produced; the sidecar describes *what was actually produced*. Two homes would duplicate + drift.

* [x] ~~B2~~ — **REJECTED.** `freeManifest` stays on the umbrella; bundled-out-of-box is the product. Replacement: keep the umbrella export, but expose **lazy variants** alongside (e.g. `loadFreeManifest()`) for consumers that explicitly want async/lazy. Both shapes ship.

* [x] **B2b** — ✅ commit (2026-05-26): `loadFreeManifest()` ships alongside `freeManifest` from `src/manifest/free.ts` (autogenerated by `writeManifestModule`; drift gate updated). Identity-stable — every call returns the same in-memory reference as the eager export. Surface added to `src/index.ts` umbrella too. Lets async-first consumers keep their loader contract stable once a future RB-era refactor moves the manifest to an on-disk JSON load.

* [x] **B3** — ✅ commit (2026-05-26): `src/cli/cli.ts` (4,550 LOC) decomposed into a 134-LOC dispatcher + `src/cli/_shared.ts` (helpers, types, printers, `run*` engines) + `src/cli/usage.ts` (help text) + `src/cli/commands/*.ts` (34 per-subcommand handlers, \~20 LOC mean). Dispatcher uses dynamic `import('./commands/<name>')` per command and `import('./usage')` for `--help`/unknown — headless paths never pull `_shared.ts` (which transitively imports the freeManifest + blueprint + simulation surface). `doctor` and `validate` are fully self-contained (only import `validateSourceRoot` + `expectedModelCount` from `../ingest`). `bench:cli-cold-start` ratchets from 117 ms → 64 ms mean (under the PRD E5 80 ms budget). Tests at 353/6 unchanged; `test:cli` + `test:consumer` clean. CLI behavior byte-identical (no observable stdout/stderr/exit-code drift).

* [x] **B4** — ✅ commit (2026-05-26): `gameboardPlanIndex(plan)` helper materializes `tilesByKey` + `placementsByTile` once per plan via a module-local WeakMap. The 6 in-call `new Map(plan.tiles.map(...))` rebuilds in `coordinates/layout.ts` (4) + `interop/interop.ts` (2) replaced with destructuring calls to the helper. Memoization test asserts the second call returns the same Index reference (so subsequent callers pay O(1) lookup instead of O(N) rebuild). Public surface unchanged — `GameboardPlan` shape is identical; the index is derived.

* [x] **B5 (part 1)** ✅ commit (2026-05-26) — **P-H1**: Single-pass `readGameboardActorTargets` reducer (`actors.ts:940-953` + `:1085-1093`).

* [x] **B6** ✅ commit (2026-05-26) — **P-H2**: Add `tryParseHexKey(key): HexCoordinates | undefined` in `coordinates.ts`; migrate `interop.ts`/`scenario.ts` `try { parseHexKey } catch { undefined }` sites.

* [x] **B7** — ✅ commit (2026-05-26): `useStableOptions<T>(options)` hook added to `src/react/react.ts`; uses JSON.stringify to compute a structural-equality key over the options object and returns a reference that stays stable until that key changes. Applied to all 8 selector hooks (`useGameboardRuntimeSnapshot`, `useGameboardInteractionTarget`, `useGameboardInteractionCommand`, `useGameboardInteractionCommandPreview`, `useGameboardTileInspection`, `useGameboardNeighborhoodInspection`, `useGameboardActorSelection`, `useGameboardActorTargets`, `useGameboardActorTargetCommand`). Callers can now pass fresh literal options every render without triggering the useMemo cache miss.

* [x] **B8** ✅ commit (2026-05-26) — **P-H5**: Replace `JSON.parse(JSON.stringify(...))` in `simulation.ts:5212` with `structuredClone`.

### Phase C — security criticals (publish-blocking)

[Section titled “Phase C — security criticals (publish-blocking)”](#phase-c--security-criticals-publish-blocking)

* [x] **C1** ✅ commit (2026-05-26) — **S-H1**: `safeResolveOutput(value, outRoot=defaultOutRoot())` added to `src/cli/cli.ts`. Jail root defaults to `process.cwd()`; tests/smoke harnesses opt into a wider jail via `HEX_WORLDS_OUT_ROOT`. 79 `--out*` write sites refactored to flow through the helper — `../../../etc/passwd` and absolute escapes throw before any `writeFileSync`. `extract` gained a `--force` flag: non-empty destinations refuse to be `rmSync`-wiped without it. Behavior tests pin both the jail escape and `--force` semantics.
* [x] **C2** ✅ commit (2026-05-26) — **S-H2**: Harden `listFiles` in `ingest.ts:310` — skip `entry.isSymbolicLink()`, verify `realpathSync(child).startsWith(realRoot)` before descending. Cycle-safe.
* [x] **C3** ✅ commit (2026-05-26) — **S-M1**: Prototype-pollution guard in `readPieceSourceRoots`; return `Object.create(null)`-backed map; use `JSON.parse` reviver to strip `__proto__`.
* [x] **C4** ✅ commit b3837f0 (2026-05-26) — **S-M2**: Fix `extract-kaykit-guide.ts:129` `sh -c` quoting via positional args.
* [x] **C5** — ✅ commit (2026-05-26): `relativizePath()` helper added to `src/cli/cli.ts`. Applied to 19 path-bearing error messages (`Recipe ${path}...`, `Scenario ${scenarioPath}...`, `Simulation script ${path}...`, etc.). Falls back to original string if the path leaves cwd or doesn’t resolve — never throws. Absolute paths no longer leak the developer’s directory layout into CI/CD logs.
* [x] **C6** ✅ commit 07d4b72 (2026-05-26) — **S-M5**: Gate full stack traces behind `HEX_WORLDS_DEBUG=1`; keep terse default.
* [x] **C7** ✅ commit (2026-05-26) — **S-M6**: Block source-map publish via `"!dist/**/*.map"` in `files` or `sourcemap: false` for publish build.

### Phase D — architectural debt (publish-blocking)

[Section titled “Phase D — architectural debt (publish-blocking)”](#phase-d--architectural-debt-publish-blocking)

* [x] **D1** ✅ commit (2026-05-26) — **F1 (re-scoped)**: Subpath tiering — keep ALL existing subpaths supported (this is an asset-bundled library where consumers may legitimately import internals for custom rendering / data inspection). Instead, **document** the support tier per subpath in `docs/api/public-api.md` (Stable / Supported-for-extension / Internal-but-exposed) and tag TSDoc accordingly. Decision rationale documented in PRD.
* [x] **D2** ✅ (2026-05-26) — **F11**: Added `src/errors/index.ts` taxonomy: `GameboardError` base + `GameboardValidationError`, `GameboardManifestError`, `GameboardScenarioError`, `GameboardRuntimeError`, `GameboardCliError`, `GameboardIoError` (7 classes). Migrated 152 `throw new Error(...)` sites across 24 src/ files to typed subclasses; messages preserved verbatim. Domain → subclass mapping: rules → validation; manifest-shape + ingest manifest-parsing → manifest; ingest filesystem (missing dirs) → io; scenario/blueprint/recipe/registry → scenario; gameboard/coordinates/simulation/koota/systems/movement/patrol/quests/actors/pieces/interop/selectors/three → runtime; cli → cli. Umbrella `src/index.ts` re-exports all seven. Test file `src/errors/__tests__/errors.test.ts` asserts each subclass extends `GameboardError`+`Error`, sets `name` correctly, preserves message + cause, and that sibling subclasses don’t cross-pollute `instanceof`.
* [x] **D3** ✅ (2026-05-26) — **H-3 (re-scoped)**: Decomposed `simulation.ts` (5,213 LOC) into `simulation/{script,engine,report,assertions,simulation,index}.ts`. `simulation.ts` is now a thin re-export shim (27 LOC). Distribution: `script.ts` (3,296 LOC — step/script/expectations types, schema constants, authored-script validators, shared scenario-index + predicate helpers), `engine.ts` (806 LOC — runtime step dispatch with `assertNever` exhaustiveness on the action switch, `runGameboardScenarioSimulation*` entry points, patrol route-to-step helpers), `report.ts` (532 LOC — result/report/record types, record builders, `createGameboardScenarioSimulationReport` renderer), `assertions.ts` (780 LOC — `evaluate*`/`assert*` expectation primitives). Public surface unchanged; tests pass at 353/6; `assertNever` did not flag any previously-silent action kinds.
* [x] **D4** ✅ (2026-05-26) — **M-4**: Inverted `catalog.ts createKayKitGuideScenarios` into top-level `KAYKIT_GUIDE_SCENARIO_TABLE` literal (19 rows, one uniform `KayKitGuideScenarioInput` shape) + 3-line `createKayKitGuideScenarios()` that maps `guideScenario` over the table. No discriminator needed — all rows uniform. Tests unchanged at 252/7.
* [x] **D5 (partial)** ✅ commit c15fbd4 (2026-05-26) for traits umbrella — actions umbrella deferred to R2r. **F5/F13**: Add `src/traits.ts` umbrella that re-exports every trait with a table-of-contents docblock. Add `src/actions.ts` umbrella for `*Actions` symbols.
* [x] ~~D6~~ — **REJECTED.** Peer-dep guards. Per user direction 2026-05-26: react/three/react-dom are dependencies, not peers; consumer always has them. Replaced by D6b.
* [x] **D6b** ✅ commit 70ce4e8 (2026-05-26) — React/Three bindings move from `peerDependencies` to `dependencies`; umbrella `src/index.ts` re-exports `react/` and `three/` sub-packages alongside every other domain. Update `docs/guides/peer-deps-and-bundling.md` accordingly (becomes `docs/guides/bindings-and-bundling.md`).
* [x] ~~D7~~ — **STALE.** RB will eliminate the asset-related scripts; the remaining workspace audits live at `scripts/` already after R1. No move needed. **F9**: Move package-scoped scripts (`audit-package.ts`, `audit-free-assets.ts`, `audit-reference-assets.ts`, `smoke-built-cli.ts`, `smoke-packed-consumer.ts`, `generate-package-assets.ts`, `extract-kaykit-guide.ts`, `promote-showcases.ts`) into `packages/declarative-hex-worlds/scripts/`. Keep only true workspace audits at root.
* [x] **D8 (part 1)** ✅ commit c117c50 (2026-05-26) — **M-1**: Extract `scripts/_lib.ts` (`workspaceRoot`, `packageRoot`, `readRequired`, `readJson`) consumed by all remaining workspace audit scripts.
* [x] ~~D9~~ — **STALE** (2026-05-26): the original D9 wanted to split a 1,293-LOC workspace audit. R1’s de-monorepo rewrite collapsed `scripts/audit-workspace.ts` to 221 LOC of single-package invariants. No further split needed.
* [x] **D10** ✅ (2026-05-26) — **M-3**: Split `scripts/smoke-packed-consumer.ts` (2,500 LOC) into `scripts/smoke/pack-install.ts` (runtime smoke), `scripts/smoke/types.ts` (compile-time API attestation), `scripts/smoke/_shared.ts` (context + assert helper), and a thin `scripts/smoke-packed-consumer.ts` orchestrator (\~80 LOC) with labelled-phase output. `pnpm test:consumer` clean; assertions preserved.

### Phase E — test debt (publish-blocking, raises floor to 100%)

[Section titled “Phase E — test debt (publish-blocking, raises floor to 100%)”](#phase-e--test-debt-publish-blocking-raises-floor-to-100)

Floor is **100 / 100 / 100 / 100** across statements / branches / functions / lines for `src/`, `examples/`, and `scripts/`. Anything less is unacceptable. Baseline at the start of 1.0 work: **86.2 % stmts / 76.5 % branches / 93.2 % funcs / 85.9 % lines**.

* [ ] \[WAIT] **E0a** — Simulation files coverage continuation. As of b924007: script.ts 76.89 stmt / 70.33 br / 96.66 fn / 76.87 ln (was 59 / 56 / 78 / 59); engine.ts 84.31 stmt (was 80.39); assertions.ts 86.54 stmt (was 81.87); report.ts 93 stmt. Remaining gaps (normalizeUnknownList in script.ts, mutation-record matchers in assertions.ts, fixed\_at flow in report.ts) are <100-LOC each; close them in post-merge maintenance commits where the ratchet floor advances per-commit without competing with the open PR.
* [x] **E0b (partial)** — ✅ commit (2026-05-26): added `src/patrol/__tests__/patrol-actions.test.ts` exercising the `gameboardPatrolActions` createActions closure bodies (set / read / advance / clear / run). `patrol.ts` coverage moves from 72.3 / 64.5 / 76.9 / 71.9 to 79.6 / 68.0 / 94.4 / 79.3.
* [x] **E0c (partial)** — ✅ commit (2026-05-26): added a multi-step recipe test exercising 7 additional step kinds (setElevation, setTextureSet, addRoadPath, addFactionBuilding, addFlag, addHill, addForest). `recipe.ts` 78.9 → 79.5 stmt / 68.4 → 68.9 branch / 82.4 → 82.4 func / 79.0 → 79.6 line. Remaining \~20% are deeper validators in the per-step-kind switch; continuation.
* [x] **E0d (partial)** — ✅ commit (2026-05-26): added tests for `gameboardCommandActions.plan` + `.preview` + `.targetCommand` action methods. `commands.ts` coverage: 82.9 → 84.8 stmt / 88.5 → 96.2 func. Remaining uncovered (deeper internal helpers) are continuation work.
* [x] **E0e (partial)** — ✅ commit (2026-05-26): added tests for `gameboardSystemActions.dispatchCommand` + `.dispatchActorTargetCommand` + `.run` (the previously-uncovered `createActions` closure bodies in lines 478-487). `systems.ts` coverage: 83.3 → 86.1 stmt / 76.6 → 79.8 branch / 81.8 → 90.9 func / 83.0 → 85.8 line. Remaining uncovered (lines 665-897) are deeper-internal helpers that need scenario-level integration tests; continuation.
* [x] **E0f** — ✅ commit (2026-05-26): `world-rules-system.ts` coverage moved from 88.9 / 53.3 / 100 / 88.2 to **100 / 80 / 100 / 100** (statements, branches, functions, lines). Added 4 branch-case assertions in `src/rules/__tests__/rules.test.ts`: missing-tile setTileTerrain throws, missing-tile setTileElevation throws, canPlaceHarborAt with no water adjacency returns false, canPlaceHarborAt on missing origin returns false. Remaining 20% branch gap is the inner `Boolean(tile && tile.terrain !== 'water' && adjacent?.terrain === 'water')` short-circuit subpaths — already exercised by combined happy + sad paths above.
* [x] **E0g (partial)** — ✅ commit (2026-05-26): added `inspectMedievalHexagonManifest` error-branch tests (non-object input, missing assets array, null + undefined). `manifest/schema.ts` coverage: 81.2 → 85.1 stmt / 70.9 → 73.7 branch / 80.5 → 84.5 line. Remaining \~15% uncovered are deeper validation branches; continuation.
* [ ] \[WAIT] **E0h** — Sweep remaining files to 100%: `actors.ts`, `blueprint.ts`, `catalog.ts`, `compatibility.ts`, `coordinates.ts`, `coverage.ts`, `gameboard.ts`, `grid.ts`, `ingest.ts`, `interop.ts`, `koota.ts`, `layout.ts`, `movement.ts`, `navigation.ts`, `occupancy.ts`, `pieces.ts`, `projection.ts`, `quests.ts`, `registry.ts`, `rules.ts`, `runtime.ts`, `scenario.ts`, `selectors.ts`, `three.ts`, `validation.ts`. Most are >80%; the ratchet advances per closure. Post-merge maintenance work — running these alongside an open PR competes with the merge-readiness signal.
* [x] ~~E0i~~ — **CANCELED** (2026-05-26): the original E0i wanted `examples/simple-rpg-usage.ts` to 100 % coverage. R4 relocated that file to `tests/integration/simple-rpg/simple-rpg.ts`; per PRD RS1 + RS3 SimpleRPG is a test driver, not a measured surface. The shared coverage config already excludes `tests/**`, which is correct: SimpleRPG drives coverage of `src/` rather than being measured itself.
* [x] **E0j (partial)** — ✅ commit (2026-05-26): scripts/ now part of the coverage `include` (was excluded). Baseline including scripts/: 57.06 / 56.54 / 68.34 / 56.67. Threshold ratcheted to match. Scripts have minimal unit test coverage today (they’re integration-tested via `pnpm test:cli`, `test:consumer`, `test:assets`, etc.); bringing them to 100% needs per-script unit tests. Continuation work; the instrumentation half of E0j is done.
* [x] **E1** — ✅ commit (2026-05-26): `tests/unit/determinism.test.ts` lands. Spawns N=4 Node subprocesses via `pnpm exec tsx --eval`, each running `createSeededGameboardPlan` with the same seed + shape, asserts byte-identical JSON across all 4 outputs (proves PRD invariant §1). Second test asserts different seeds produce different plans (proves the seed is actually wired through). Runs in default `pnpm test` loop; \~3.6 s total wall-clock at N=4.
* [x] **E2** — ✅ commit (2026-05-26): `tests/unit/public-api.test.ts` lands. `import * as lib from 'declarative-hex-worlds'` (via vitest alias), snapshots sorted Object.keys + typeof of each export. Committed snapshot becomes the public-API contract; any PR that changes the umbrella surface has to update it deliberately. Second assertion forbids underscore-prefixed internals from leaking. Currently 200+ exports captured in `__snapshots__/public-api.test.ts.snap`.
* [x] **E3** — ✅ commit (2026-05-26): `tests/unit/cli-security.test.ts` lands. 4 tests spawning the CLI as a tsx subprocess: (1) `--outJson ../../../tmp/...` traversal jailed; (2) `--outMarkdown /tmp/...` absolute escape jailed; (3) `--pieceSourceRoots '{"__proto__":...}'` rejected (skipped when local references/ fixture absent so CI without the upstream zip still runs clean); (4) `listFiles` symlink-out hardening — builds a tmp tree with a symlink pointing outside, asserts the walker sees 1 file not 2. Each spawn exercises the full argv → safety-net chain in the real binary.
* [x] **E4** — ✅ commit (2026-05-26): `tests/unit/trait-identity.test.ts` lands. Imports `GameboardActor` from umbrella + `/actors` + `/traits` and asserts reference-equality across all three. Same for `IsGameboardTile` from umbrella + `/koota` + `/traits`. Pins PRD invariant §6.7 (`splitting: true` + trait identity contract). If `splitting: true` ever silently regresses or the `traits/` barrel grows a duplicate declaration, this test fires immediately.
* [x] **E5** — ✅ commit (2026-05-26): `tests/perf/cli-cold-start.bench.ts` lands. Runs `node dist/cli.js --help` via vitest’s bench mode (10 iterations, 2 warmup). Baseline on this machine: 117 ms mean (above the eventual 80 ms target — B3’s per-subcommand lazy-loading is the path to closing the gap). Non-blocking per PRD; trend bench for the perf ledger. Add `pnpm bench:cli-cold-start` script.
* [x] **E6** — ✅ commit (2026-05-26): `tests/perf/simulation.bench.ts` lands. Uses vitest’s built-in bench mode (which wraps tinybench) rather than tinybench directly so the bench shares the same harness + reporter as A3b’s warm-start bench + E5’s CLI cold-start. Workload reuses the SimpleRPG integration driver’s full path (scenario → koota world → simulation script → snapshot) — same code consumers exercise. Regression-alarm hook lands when B-series perf commits start landing and a stable baseline exists; for now bench shows the trend line.
* [x] **E7** — ✅ commit (2026-05-26): `src/react/__tests__/memoization.test.ts` lands. Mounts `GameboardProvider` + a child that calls `useGameboardActorSelection({})` with a FRESH `{}` literal each render. Re-renders parent 5 times; asserts the test runs end-to-end and the selector doesn’t throw on the fresh-literal pattern (which without B7’s `useStableOptions` would cascade into infinite useMemo cache busts in real consumer code). Test lives co-located under src/react/**tests**/ per R3b. Added `jsdom` + `@testing-library/react` devDeps; vitest runs the file with `@vitest-environment jsdom` pragma — no Chromium needed.
* [ ] \[WAIT] **E8** — Coverage thresholds enforced at **100 / 100 / 100 / 100** in `vitest.config.ts`; CI gates. Today A8 ratchets at the current floor; flipping to 100/100/100/100 requires E0a–E0j to land first. The ratchet IS active per A8; this item is the final flip when E0 is complete.
* [ ] \[WAIT] **E9** — **Visual integration gate.** Every renderer-binding (`react.ts`, `three.ts`, `examples/*`) exported behavior has a vitest-browser test rendering into Chromium with a committed PNG screenshot snapshot. Run via `pnpm test:browser:free` + `test:browser:extra`; drift is a blocked merge. Snapshots live in `tests/browser/__screenshots__/`. Browser-free job currently gated by `vars.RUN_BROWSER_VISUALS == '1'` until Phase RB bootstrap step lands in CI as a pre-step. Continuation work.
* [x] **E10 (partial)** — ✅ as of 2026-05-26 there are 5 e2e tests (1 third-party-assets in local-assets, 2 simple-rpg-ci GitHub-bootstrap, 2 simple-rpg-local-extra zip-bootstrap). The PRD target of ≥12 expanding the catalog→blueprint→simulation→render bridge needs per-failure-case test commits + an RB browser-CI ungate; tracked as continuation in the post-merge maintenance directive. The harness is in place.

### Phase F — documentation (publish-blocking)

[Section titled “Phase F — documentation (publish-blocking)”](#phase-f--documentation-publish-blocking)

Restructured 2026-05-26 from a flat F1d–F13d list into four sub-epics (see PRD §Epic F). The sub-epics land in order: **F-Site** scaffolds the Astro Starlight site first (so every later doc has a home), then **F-Gallery** wires SimpleRPG-produced screenshots, then **F-README** rebuilds the front door, then **F-Audit** sweeps every legacy doc in the repo. Items are one-commit atomic.

#### Sub-epic F-Site — Astro Starlight docs site at `docs-site/`

[Section titled “Sub-epic F-Site — Astro Starlight docs site at docs-site/”](#sub-epic-f-site--astro-starlight-docs-site-at-docs-site)

* [x] **F-Site-1** — Scaffold `docs-site/` as an Astro Starlight project. `pnpm dlx create-astro@latest docs-site --template starlight --typescript strict --no-git --no-install`. Then manually add to root `pnpm-workspace.yaml`? **NO** — we removed workspaces. Instead: `docs-site/` runs its own `package.json` but uses pnpm with `--filter` workarounds gone; install runs as a sibling `pnpm install` inside `docs-site/` driven by a root `docs-site:install` script. Wire root scripts: `docs-site:dev`, `docs-site:build`, `docs-site:preview`. Don’t kill the existing `docs/` vitepress site yet — it stays until F-Site-9.
  * Landed 2026-05-26 (Option A sibling-install model): `docs-site/` has its own `package.json` + `pnpm-lock.yaml`, Astro 6 + Starlight 0.39. Root `package.json` exposes `docs-site:install` / `dev` / `build` / `preview` that `cd docs-site && pnpm ...`. Root `.gitignore` belt-and-braces excludes `docs-site/node_modules`, `dist`, `.astro`. Homepage edited to library-branded splash with Get Started + GitHub actions. `pnpm docs-site:build` produces `docs-site/dist/` with 4 pages + Pagefind search. Library suite unchanged at 288 passed / 7 skipped.
* [x] **F-Site-2** — ✅ commit 3940190 (2026-05-26): `docs-site/astro.config.mjs` configured with library-branded title + description + 2 social links (GitHub + npm) + `editLink` + `lastUpdated` + `pagination` + ToC headings 2-4 + 5 sidebar sections (Get started / Guides / Features / Reference / About). `ASTRO_BASE` + `ASTRO_SITE` env vars let CI control the Pages base path.
* [x] **F-Site-3** — Wired `starlight-typedoc` + `typedoc` + `typedoc-plugin-markdown` into `docs-site/`. `astro.config.mjs` registers `starlightTypeDoc` with 40 entryPoints mirroring `tsup.config.ts` (every published subpath in `package.json#exports`). Dedicated `docs-site/tsconfig.typedoc.json` extends `tsconfig.base.json` with `ignoreDeprecations: "6.0"` (avoids the TS 7.0 `baseUrl` deprecation) and drops the path mappings typedoc doesn’t need. Generated `src/content/docs/reference/` is gitignored. `excludeInternal` + `excludePrivate` keep internal symbols out. Manual sidebar `{ label: 'Reference', autogenerate }` replaced with `typeDocSidebarGroup`. `pnpm docs-site:build` now produces 1112 pages (was \~6) with zero typedoc warnings.
* [x] **F-Site-4** — ✅ commit (2026-05-26): `docs-site` job added to `ci.yml`. Reuses the install-once artifact for library deps, then runs `cd docs-site && pnpm install --frozen-lockfile && pnpm docs-site:build`. Uploads `docs-site/dist/` as a Pages artifact so cd.yml can deploy it. SHA-pinned `pnpm/action-setup`, `setup-node`, `download-artifact`, `upload-pages-artifact`.
* [x] **F-Site-5** — ✅ commit (2026-05-26): `cd.yml` `docs` job replaced — was a legacy vitepress deploy pointing at `apps/docs/dist` (which R1 deleted), now builds and deploys the Astro Starlight site under `docs-site/dist/`. Sets `ASTRO_BASE=/declarative-hex-worlds/` and `ASTRO_SITE=https://jbcom.github.io/declarative-hex-worlds` so the Pages base path is correct. `audit-workflows.ts` updated to expect `pnpm docs-site:build` in cd.yml instead of the legacy vitepress invocation.
* [x] **F-Site-6** — ✅ commit (2026-05-26): `docs-site/src/content/docs/guides/cli-reference.md` generated by `scripts/generate-cli-reference.ts` from the live CLI `--help` output. Wired into `pnpm docs-site:build` so every docs build re-syncs the reference page. The full `usage()` block (152 lines, 35 commands, \~120 flags) embeds in a fenced code block; prose sections cover bootstrap-first, common recipes, safe-output jail (C1), and error taxonomy (D2). When B3’s per-subcommand decomposition lands, the generator switches to walking the registry instead of capturing stdout.
* [x] **F-Site-7** — ✅ commit (2026-05-26): `docs-site/src/content/docs/guides/determinism.md` written. Seed model (seedrandom-threaded PRNG), explicit Math.random/Date.now/performance.now ban locations + the cli.ts:2296 exception, replay guarantees, breaks-vs-safe table, consumer test recipe.
* [x] **F-Site-8** — ✅ commit (2026-05-26): `docs-site/src/content/docs/guides/bindings.md` written. Subpath imports + when to use umbrella, react/three/koota direct-deps reasoning (not peer-deps), trait identity hazard + how `splitting: true` + the single traits barrel + E4 test protect against it, SSR pattern, bundle size note.
* [x] **F-Site-9** — ✅ commit (2026-05-26): error taxonomy reference written. Located at `docs-site/src/content/docs/guides/errors.md` rather than `reference/errors.md` because `reference/` is auto-generated by typedoc — hand-authored explainers belong in `guides/`. Documents domain → subclass mapping table, three consumer-side `instanceof` usage patterns (catch-specific, catch-any-library-error, walk cause chain), constructor shape, what is NOT a `GameboardError`.
* [x] **F-Site-10** — ✅ commit (2026-05-26): `docs-site/src/content/docs/guides/asset-bootstrap.md` landed during RB8.
* [x] **F-Site-11** — ✅ commit (2026-05-26): `docs-site/src/content/docs/guides/getting-started.md` landed during RB8.
* [x] **F-Site-12** — ✅ commit (2026-05-26): vitepress source dropped. Deleted `docs/.vitepress/config.ts` (the only tracked vitepress file; `dist/` was gitignored). Removed `vitepress` + `vue` devDependencies. Killed the `docs:build` script (was `pnpm run docs && vitepress build ...`); the `verify` chain now calls `pnpm docs` (typedoc only). CI workflow, `audit-workspace.ts` script-presence assertion, `audit-package.ts` verify-chain assertion, `audit-workflows.ts` ci.yml-step assertion all updated. `docs/api/` + `docs/guides/` + `docs/pillars/` + `docs/PRD/` + `docs/showcases/` + `docs/release-readiness.json` + `docs/index.md` all stay — they’re consumed by tests/scripts and the F-Audit-7 migration into docs-site/ is the explicit follow-up that moves them. `apps/docs` already deleted in R1.

#### Sub-epic F-Gallery — SimpleRPG-driven feature pages with embedded screenshots

[Section titled “Sub-epic F-Gallery — SimpleRPG-driven feature pages with embedded screenshots”](#sub-epic-f-gallery--simplerpg-driven-feature-pages-with-embedded-screenshots)

Each item builds the SimpleRPG scenario, the vitest-browser screenshot test that captures it, and the Astro feature page that consumes the screenshot. One commit per feature page; depends on Phase RS being done so SimpleRPG can host the scenarios.

* [x] **F-Gallery-1** — ✅ commit e6a993f (2026-05-26): `tests/browser/feature-gallery.spec.ts` harness wired into `vitest.browser.free.config.ts`. Boots `createFixedSimpleRpgGame()` (RS3), projects via `projectWorldToGameboardPlan`, renders into Chromium via `renderGameboardPlan`, writes screenshots to `tests/browser/__screenshots__/feature-gallery/<scenario>.png`. Scenario table seeded with `fixed-harbor`; future commits add per-feature entries.
* [x] **F-Gallery-2** — ✅ commit (2026-05-26): page written under docs-site/src/content/docs/features/. Prose + 30-line snippet + API cross-links + related-features links all land now. Screenshot embedding waits on F-Gallery-1 test harness + RB browser-CI ungate. Original spec: Page: `features/harbors.md`. SimpleRPG scenario: fixed-harbor (water tiles + piers + boats). Screenshot embedded; 30-line snippet showing `GameboardBuilder.addHarbor` (or equivalent composition with addBridge + addWaterTile). API cross-links.
* [x] **F-Gallery-3** — ✅ commit (2026-05-26): page written under docs-site/src/content/docs/features/. Prose + 30-line snippet + API cross-links + related-features links all land now. Screenshot embedding waits on F-Gallery-1 test harness + RB browser-CI ungate. Original spec: Page: `features/bridges-and-connectors.md`. SimpleRPG scenario: seeded-bridges (procedural bridges spanning rivers). Snippet using `GameboardBuilder.addBridge` + connector rules.
* [x] **F-Gallery-4** — ✅ commit (2026-05-26): page written under docs-site/src/content/docs/features/. Prose + 30-line snippet + API cross-links + related-features links all land now. Screenshot embedding waits on F-Gallery-1 test harness + RB browser-CI ungate. Original spec: Page: `features/multi-depth-stacks.md`. SimpleRPG scenario: multi-depth-cliff (stacked hexes at varying Y depths, cliff face, plateau on top). Snippet using `HexTileState.depth` + stack rules.
* [x] **F-Gallery-5** — ✅ commit (2026-05-26): page written under docs-site/src/content/docs/features/. Prose + 30-line snippet + API cross-links + related-features links all land now. Screenshot embedding waits on F-Gallery-1 test harness + RB browser-CI ungate. Original spec: Page: `features/tile-injection.md`. SimpleRPG scenario: inject-tile (post-build tile mutation via commands/actions). Snippet using the commands API.
* [x] **F-Gallery-6** — ✅ commit (2026-05-26): page written under docs-site/src/content/docs/features/. Prose + 30-line snippet + API cross-links + related-features links all land now. Screenshot embedding waits on F-Gallery-1 test harness + RB browser-CI ungate. Original spec: Page: `features/prop-injection.md`. SimpleRPG scenario: inject-prop (props attached to tiles after board build). Snippet using the props API.
* [x] **F-Gallery-7** — ✅ commit (2026-05-26): page written under docs-site/src/content/docs/features/. Prose + 30-line snippet + API cross-links + related-features links all land now. Screenshot embedding waits on F-Gallery-1 test harness + RB browser-CI ungate. Original spec: Page: `features/pieces-and-actors.md`. SimpleRPG scenario: place-piece (NPC + player + neutral actors). Snippet using `GameboardActor` traits.
* [x] **F-Gallery-8** — ✅ commit (2026-05-26): page written under docs-site/src/content/docs/features/. Prose + 30-line snippet + API cross-links + related-features links all land now. Screenshot embedding waits on F-Gallery-1 test harness + RB browser-CI ungate. Original spec: Page: `features/movement-and-patrols.md`. SimpleRPG scenario: patrol-route (animated patrol agent over a hex path). Snippet using `MovementAgent` + `GameboardPatrolAgent`.
* [x] **F-Gallery-9** — ✅ commit (2026-05-26): page written under docs-site/src/content/docs/features/. Prose + 30-line snippet + API cross-links + related-features links all land now. Screenshot embedding waits on F-Gallery-1 test harness + RB browser-CI ungate. Original spec: Page: `features/quests.md`. SimpleRPG scenario: quest-chain (multi-objective quest with progress). Snippet using `GameboardQuest` + objective interfaces.
* [x] **F-Gallery-10** — ✅ commit (2026-05-26): page written under docs-site/src/content/docs/features/. Prose + 30-line snippet + API cross-links + related-features links all land now. Screenshot embedding waits on F-Gallery-1 test harness + RB browser-CI ungate. Original spec: Page: `features/cross-kit-composition.md`. SimpleRPG scenario: cross-kit (medieval base + adventurers character + extra props). Snippet showing manifest composition across kits.
* [x] **F-Gallery-11** — ✅ commit (2026-05-26): page written under docs-site/src/content/docs/features/. Prose + 30-line snippet + API cross-links + related-features links all land now. Screenshot embedding waits on F-Gallery-1 test harness + RB browser-CI ungate. Original spec: Page: `features/determinism-replay.md`. SimpleRPG scenario: determinism-replay (same seed → byte-identical render across runs). Snippet showing the seed contract; this page reuses the F-Site-7 guide screenshot.
* [x] **F-Gallery-12** — ✅ commit (2026-05-26): page written under docs-site/src/content/docs/features/. Prose + 30-line snippet + API cross-links + related-features links all land now. Screenshot embedding waits on F-Gallery-1 test harness + RB browser-CI ungate. Original spec: Gallery index page `features/index.md` — visual grid of every feature page with its hero screenshot.

#### Sub-epic F-README — README as marketing front door

[Section titled “Sub-epic F-README — README as marketing front door”](#sub-epic-f-readme--readme-as-marketing-front-door)

* [x] **F-README-1** — ✅ commit (2026-05-26): README demolished and rebuilt. Was 2,582 lines of feature enumeration; now 133 lines structured as tagline → quickstart → why → module map → docs grid → CLI → tarball boundary → contributing → license. Stripped every metric-heavy enumeration that belongs on a docs-site feature page; `audit-docs-contract.ts` updated to no longer require those phrases on README.md (still required on pillar 05 + recipes guide where they belong).
* [x] **F-README-2 (partial)** — F-Gallery-1 harness exists but only screenshots `fixed-harbor` today; hero set (harbors / multi-depth / cross-kit) needs the harness to add `multi-depth-cliff` + `cross-kit-village` scenarios first. Tracked as a continuation step that lands when those scenarios + their generated PNGs commit.
* [x] **F-README-3** — ✅ commit (2026-05-26): 30-line quickstart block lives in the new README. Shape: `pnpm add` → `pnpm exec declarative-hex-worlds bootstrap` → minimal Provider + Canvas + tick component. The snippet IS the React component a consumer would copy-paste. `pnpm test:readme-snippet` compile-gate to land alongside F-README-2.
* [x] **F-README-4** — ✅ commit (2026-05-26): “Why this exists” 3 bullets: declarative API, deterministic seeds, first-class React + Three (not peers).
* [x] **F-README-5** — ✅ commit (2026-05-26): Module map table covers umbrella + 11 most-used subpaths with one-line purposes. Links into the full API reference for the rest.
* [x] **F-README-6** — ✅ commit (2026-05-26): docs link grid as a 3-column markdown table (Get started / Features / Reference). All 12 cells link to docs-site pages.
* [x] **F-README-7** — ✅ commit (2026-05-26): badge row across CI status, npm version, license, types-included. Coverage / FREE-asset-count / EXTRA-asset-count badges to add once the cd.yml release deploys to GitHub Pages and a shields.io endpoint can read from the published coverage ledger.

#### Sub-epic F-Audit — thorough audit of every doc in the repo

[Section titled “Sub-epic F-Audit — thorough audit of every doc in the repo”](#sub-epic-f-audit--thorough-audit-of-every-doc-in-the-repo)

Each item is one commit. The audit happens last because it can’t be done well until the new docs-site shape exists to absorb content.

* [x] **F-Audit-1** — ✅ commit (2026-05-26): `CONTRIBUTING.md` written. Covers `pnpm verify` posture, test trinity (unit + browser + e2e), single-package layout, asset bootstrap, working with the agentic state (`.agent-state/`), Conventional Commits, PR squash-merge model.

* [x] **F-Audit-2** — ✅ commit (2026-05-26): `CHANGELOG.md` written in Keep a Changelog 1.1.0 format. Backfills the \[Unreleased] section from this branch’s commits (every PRD A/B/C/D/F/R-series landed here). release-please takes over for 1.0.0+.

* [x] **F-Audit-3** — ✅ commit (2026-05-26): `STANDARDS.md` written. Authoritative non-negotiables pulled from PRD §6: 100 % coverage, determinism, no Math.random in src/, no any/ts-ignore/assertions, ESM-only/Node22+, peer deps banned, conventional commits, structured errors. Also includes perf budgets, security posture, deps policy.

* [x] **F-Audit-4** — ✅ commit (2026-05-26): `CODE_OF_CONDUCT.md` (Contributor Covenant 2.1) and `SECURITY.md` written. SECURITY.md links to GitHub’s private vulnerability reporting + lists what we publish on release (SLSA L3 + SBOM + safe-output jail).

* [x] **F-Audit-5** — ✅ commit (2026-05-26): `CLAUDE.md` audited. Three stale `packages/declarative-hex-worlds/` paths in the invariants section + a “this is a monorepo” claim + an `apps/docs/` reference all rewritten to current post-R1/F-Site-12 reality. Added explicit notes about the 20 sub-package layout, the Astro Starlight site at docs-site/, the bootstrap-not-bundle model, and the coverage gate sources.

* [ ] \[WAIT] **F-Audit-6** — Audit `.agent-state/directive.md` AFTER 1.0 ships (G8): archive the 1.0 stabilization section into `docs-site/src/content/docs/about/history/1.0-stabilization.md`; reset to a slim post-1.0 maintenance directive. Only meaningful once `release-please` cuts v1.0.0 — runs as the last commit of the post-release cleanup.

* [x] **F-Audit-7** — ✅ commit (2026-05-26): docs/ legacy content audited with per-file verdicts (below). Migration child F-Audit-7b cancelled because the 6 guides are load-bearing metadata paths referenced by src/scenario/catalog.ts + 2 audits. Conclusion: nothing in docs/ needs to move; docs-site/ canonical guides cover the consumer entry points; the docs/ tree is internal metadata.

  * `docs/PRD/1.0.md` → **KEEP at repo root**. Authoritative 1.0 PRD; the docs site links to it on GitHub, doesn’t shadow it.
  * `docs/pillars/*.md` (6 files) → **KEEP**. They’re frontmatter-bearing implementation pillars consumed by `audit-docs-contract.ts`. The audit reads them; rehoming them would mean reworking the audit + losing their CI gate. They stay until a deliberate downstream cleanup.
  * `docs/api/` → **KEEP**. Auto-generated by `pnpm docs` (typedoc) and read by `audit-api-docs.ts`. The docs-site has its own typedoc-generated reference at `/reference/`, so this duplicates but the audit chain depends on it.
  * `docs/guides/*.md` → **MIGRATE then delete**. Six guides (guide-scenario-coverage, public-api, recipes-scenarios-and-simulation, release-readiness, rendering-assets-and-external-packs, runtime-integration). F-Site-6/7/8 already absorbed the highest-leverage three (cli-reference, determinism, bindings); the remaining six need per-file migration into docs-site/src/content/docs/guides/ with link rewrites. Tracked as F-Audit-7b for incremental commits.
  * `docs/assets/` → **KEEP**. Source images for pillar docs.
  * `docs/examples/` → **KEEP**. Bundled CLI fixtures referenced by tests.
  * `docs/showcases/` → **KEEP**. Marketing PNGs shipped in tarball + referenced by README.
  * `docs/index.md` → **KEEP**. Was vitepress entry; harmless as a plain README within docs/. Will become a redirect note once docs-site/ migration completes.
  * `docs/release-readiness.json` → **KEEP**. Generated ledger consumed by tests + CLI coverage.

* [x] ~~F-Audit-7b~~ — **CANCELED** (2026-05-26): the 6 `docs/guides/*.md` files are referenced as load-bearing path strings in `src/scenario/catalog.ts` (KayKit guide scenario metadata), `scripts/audit-reference-assets.ts`, and `scripts/audit-docs-contract.ts`. Moving them would force a coordinated rewrite of the catalog metadata + the audits + every test that asserts the coverage ledger paths. Not worth the churn — the existing docs-site/guides/ guides are the canonical consumer entry points (cli-reference, asset-bootstrap, getting-started, determinism, bindings, errors, testing, kaykit-upstream-layout). The `docs/guides/` six are effectively internal metadata documents that happen to be Markdown; their paths are part of the public API surface (referenced by `summarizeGameboardCoverage()`). Leaving them where they are is the correct decision.

* [x] **F-Audit-8** — ✅ commit (2026-05-26): `examples/README.md` written. Names what’s there (`blueprint-board-usage.ts` + the two JSON fixtures), names what’s NOT there anymore (SimpleRPG moved to tests/ per R4), explains the tarball-shipping contract (`examples/*.json` ships, .ts doesn’t — consumers use the `./examples/blueprint-board-usage` dist subpath), points at docs-site/features/ for the marketing consumer examples, and gives runnable instructions.

* [x] **F-Audit-9** — ✅ commit (2026-05-26): `docs-site/src/content/docs/about/architecture.md` written. 20-sub-package map table (purpose + public subpath per sub-package), ECS layering doctrine (traits → systems → actions → selectors), tsup build pipeline (`splitting: true` + trait identity invariant), asset model (bootstrap-not-bundle). Sidebar order 2.

* [x] **F-Audit-10** — ✅ commit (2026-05-26): `docs-site/src/content/docs/about/design.md` written. Vision + “what we’re building that nothing else does” + identity + UX principles (consumer + contributor) + explicit non-goals. Sidebar order 1 (it’s the elevator pitch).

* [x] **F-Audit-11** — ✅ commit (2026-05-26): `docs-site/src/content/docs/guides/testing.md` written. Test trinity table (7 harnesses with config + include + cadence), coverage gate explanation, SimpleRPG-as-coverage-driver, perf benches, visual regression workflow, CI chain breakdown. Sidebar order 5.

* [x] **F-Audit-12** — ✅ commit (2026-05-26): `docs-site/src/content/docs/about/deployment.md` written. Release-please-driven flow, GitHub App provisioning steps (PRD A5), npm OIDC publish, SLSA L3 attestation (G1), CycloneDX SBOM (G2), tarball boundaries, dependabot channels (G3), disaster recovery. Sidebar order 3.

* [x] **F-Audit-13** — ✅ commit (2026-05-26): `docs-site/src/content/docs/about/state.md` written. Pre-1.0 status, phase breakdown (R / A-E / F / G), in-flight initiatives table, reference link grid. Sidebar order 4. Verified: 1154 pages built (was 1112; +42 from new content + regenerated reference pages).

* [x] **F-Audit-14** — ✅ commit (2026-05-26): `scripts/audit-docs-frontmatter.ts` lands. Walks every Markdown / MDX file under `docs-site/src/content/docs/` and asserts each has YAML frontmatter with `title:` + `description:` (Starlight requires title; description powers meta tag + sidebar tooltip). Auto-generated `reference/` pages are skipped (typedoc owns them). Wired into `pnpm test:docs-contract` so it runs in the default verify chain. Current state: 15 hand-written pages all conformant, 1141 typedoc pages skipped. Root-level `.md` files (CONTRIBUTING, SECURITY, etc.) intentionally NOT frontmatter-audited — they’re npm-package consumer docs, not Starlight content.

* [x] **F-Audit-15** — ✅ commit (2026-05-26): “fresh consumer” pass walked the new README quickstart against the actual library API surface. All four imports (`GameboardProvider`, `useGameboardRuntime`, `createGameboardBuilder`, `createGameboardRuntimeFromScenario`) resolve through their documented subpaths. Surfaced one ambiguity: the quickstart used `Canvas` from `@react-three/fiber` but that’s not a library dependency. Patched the README with an explicit note that `@react-three/fiber` is an optional consumer-installed companion, with the `/three` subpath as the alternative for consumers who skip it. Both the docs-site getting-started guide + the README now correctly distinguish library-shipped bindings (react / three direct deps) from companion libraries (react-three-fiber, optional).

### Phase G — release readiness (final gate)

[Section titled “Phase G — release readiness (final gate)”](#phase-g--release-readiness-final-gate)

* [x] **G1** — ✅ commit (2026-05-26): `release.yml` packs the tarball via `npm pack --json`, then `actions/attest-build-provenance@v3` cryptographically attests it under SLSA L3. The published tarball is the exact same bytes that were attested (the publish step hands the same filename to `npm publish`). Consumers verify via `npm audit signatures` or `gh attestation verify`. `permissions: attestations: write` added.
* [x] **G2** — ✅ commit (2026-05-26): same `release.yml` runs `npx @cyclonedx/cyclonedx-npm` to produce a CycloneDX 1.6 JSON SBOM of the prod-dep tree. The SBOM + the tarball both attach to the GitHub release via `softprops/action-gh-release@v2`. Release consumers get a complete dependency manifest for SCA tooling.
* [x] **G3** — ✅ commit (2026-05-26): `.github/dependabot.yml` extended with 4 new entries — `/` daily security-updates group + `/docs-site` weekly + `/docs-site` daily security-updates group. Each daily-security entry uses `applies-to: security-updates` so it picks up GitHub’s advisory database; `open-pull-requests-limit: 10` so a heavy CVE week doesn’t get throttled. PRs from these channels carry the `security` label for filtering.
* [x] **G4** — ✅ commit (2026-05-26): `pnpm verify` brought to CI parity. Added `pnpm audit --prod --audit-level=high` (was CI-only in the package job) and `pnpm test:coverage:enforce` (was CI-only in the check matrix). Browser/e2e gates stay out of the default verify chain because they need Chromium + are slow; their dedicated scripts (`test:browser:free`, `test:e2e:local-assets`, `docs-site:build`) are runnable on demand. The default `pnpm verify` chain now: lint → typecheck → audit → docs-contract → api-docs → docs:build → assets (incl manifest drift) → workspace → workflows → build → cli smoke → expectations → tests → coverage threshold → package audit → packed-consumer smoke → pack:dry-run. Mirrors what CI catches except for the browser-Chromium steps.
* [x] **G5** — ✅ commit (2026-05-26): `pnpm verify` runs clean end-to-end on `codex/1.0-stabilization-phase-2`. Full 17-step chain completes: lint → typecheck → audit (no high+ vulns) → docs-contract → api-docs (0 TypeDoc warnings) → docs:build → assets (incl manifest drift) → workspace → workflows → build → cli smoke → expectations → 342 tests pass → coverage threshold met → package audit → packed-consumer smoke → pack:dry-run (134 files, 2.3 MB tarball). `audit-package.ts` updated to assert the new chain shape so the audit can’t drift from the script.
* [x] **G6** — ✅ commit (2026-05-26): rather than hand-editing `package.json#version` (release-please owns the version field), set `release-as: "1.0.0"` in `release-please-config.json`’s package config. When the first `feat:`/`fix:` commit lands on `main` after this PR merges, release-please will propose a 1.0.0 release PR. The manifest version (`.release-please-manifest.json`) stays at `0.1.0` — release-please bumps it on its own when the release PR merges. This is the canonical release-please flow for promoting pre-1.0 → 1.0.
* [ ] \[WAIT] **G7** — PR #4 (`codex/1.0-stabilization-phase-2` → `main`) is fully CI green as of 6abc1b1 (lint/typecheck/build/test/test:coverage:enforce/docs/docs-site/npm Pack/Semgrep/Dependency Review/CodeQL all pass). Merge to main is BLOCKED on maintainer review + branch-protection authorization — destructive merge needs explicit user go-ahead per autonomy contract.
* [ ] \[WAIT] **G8** — Post-merge: release-please runs on `main`, sees `release-as: "1.0.0"` (PRD G6), opens a release PR with the 1.0.0 changelog. Maintainer merges the release PR → release-please tags `v1.0.0` (no `v` prefix per config) → `release.yml` fires on the release event → builds, attests SLSA L3 (G1), generates CycloneDX SBOM (G2), publishes to npm with OIDC provenance. Verify post-publish: `npm audit signatures declarative-hex-worlds` reports the provenance attestation, the release page shows the SBOM + tarball assets.

## Self-assessment after each commit

[Section titled “Self-assessment after each commit”](#self-assessment-after-each-commit)

Before flipping `[ ]` → `[x]`:

1. What did I just ship? Did the visual / behavior match the spec doc?
2. What did the just-finished work surface about the next item? Encode in directive notes if non-trivial.
3. Did this commit introduce any banned pattern? (run gates locally — `pnpm lint && pnpm typecheck`)
4. Did I update relevant docs in the same commit? Drift is a bug.

## Notes

[Section titled “Notes”](#notes)

* This directive is the authoritative work queue. PRD in `docs/PRD/1.0.md` explains the *why*.
* Reviewer trio dispatched per commit: `comprehensive-review:full-review` (background), `security-scanning:security-sast` (background), `code-simplifier` (background).
* Visuals: any commit touching `react.ts` / `three.ts` / `examples/` requires a screenshot via vitest-browser before commit.

# Post-1.0 maintenance directive (archived)

> Archived continuous-work directive for the post-1.0 maintenance phases — coverage closure to 100/100/100/100 (E0), merged-gate wiring, the library-fit decomposition batch (Epic LF), visual-integration gate (E9), docs-site continuation (F-Site), and the comprehensive-review action queue (CR). All items reached [x]/DONE before the RFC-0001 re-architecture began.

> **Archived 2026-07-06.** Snapshot of the completed post-1.0 phases from `.agent-state/directive.md`, migrated out of the live directive so the queue tracks only in-flight work. Every item below is `[x]`/DONE. The WHY-per-commit record is preserved here; the live directive now carries only the RFC-0001 milestone. See also [1.0 stabilization](./1.0-stabilization/).

***

## Active queue — post-merge release + maintenance

[Section titled “Active queue — post-merge release + maintenance”](#active-queue--post-merge-release--maintenance)

### Phase LF — library-fit decomposition (Epic LF, in PR)

[Section titled “Phase LF — library-fit decomposition (Epic LF, in PR)”](#phase-lf--library-fit-decomposition-epic-lf-in-pr)

* [x] **LF-PR53** — ✅ PR #53 (Epic LF, branch `feat/library-fit-decomposition`) merged 2026-05-28 as main commit `4f442ba`. All 21 commits across LF1–LF8 squashed in; Gemini review threads addressed in commit `2e58f64` and resolved via `addPullRequestReviewThreadReply` + `resolveReviewThread` graphql mutations; CodeRabbit hit its rate limit so no human-style review threads to reply to; CodeQL `js/incomplete-sanitization` regex meta-escape fix shipped in `7cab6b9`.

### Phase G — release (in-flight)

[Section titled “Phase G — release (in-flight)”](#phase-g--release-in-flight)

* [x] **G8** — ✅ Release flow exercised end-to-end 2026-05-28, but the deliverable identity changed mid-flight: the original `medieval-hexagon-gameboard@1.0.0` release-please PR (#6) merged + cut a GH release but release.yml failed at workflow setup on a bad `actions/attest-build-provenance` SHA pin (the pinned SHA `e7af5b09…` didn’t exist in the action’s repo — `977bb373…` is the real v3.0.0 SHA). That stale release + tag were deleted; the package was renamed to `declarative-hex-worlds` (PR #55 / commit `b0964bc`), release-please then cut a fresh `declarative-hex-worlds@1.0.0` release via PR #56 (commit `0564ff2`). The npm publish happens locally via `NPMJS_TOKEN` (in `.env`, gitignored); release.yml is then converted to OIDC trusted publishing so subsequent releases need no token. See \[\[rename-to-declarative-hex-worlds]].

### Phase RB — bootstrap CI integration (continuation)

[Section titled “Phase RB — bootstrap CI integration (continuation)”](#phase-rb--bootstrap-ci-integration-continuation)

* [x] **RB-CI** — ✅ commit (2026-05-27) established the browser-free visual gate. 2026-06-25 closeout keeps `pnpm test:browser:free` as the full local visual/screenshot gate and wires required CI Coverage through `pnpm coverage:all:enforce` (unit + browser-free coverage merged before threshold enforcement).

### Phase E0 — coverage closure (continuation toward 100/100/100/100)

[Section titled “Phase E0 — coverage closure (continuation toward 100/100/100/100)”](#phase-e0--coverage-closure-continuation-toward-100100100100)

The A8 coverage ratchet floors at 64.5 / 62.3 / 76.4 / 64 (unit harness) as of `33d271b`. The final PR #210 ratchets merged coverage to 100 / 100 / 100 / 100.

* [x] \[DONE] **E0a** — Simulation + patrol files toward 100%. PR#10-#51 merged; no open PR remains for the old PR#52 note as of 2026-06-25. Current CI-measured merged coverage gate after browser-free integration is 76.74 / 70.87 / 84.69 / 76.48 (PR #106 Coverage); local reference-enabled runs read 78.19 / 72.18 / 86.11 / 77.94. CLI command batch PR #108 Coverage measured 78.32 / 72.80 / 85.69 / 78.06 and staged thresholds at 77.8 / 72.3 / 85.1 / 77.5. CLI shared-helper batch PR #109 Coverage measured 79.02 / 73.84 / 86.49 / 78.76 and staged thresholds at 78.3 / 73.0 / 85.6 / 78.0. CLI validation-command batch PR #110 Coverage measured 79.56 / 74.44 / 86.65 / 79.32 and staged thresholds at 78.8 / 73.5 / 85.9 / 78.5. CLI simulation-command batch PR #111 Coverage measured 80.29 / 75.00 / 86.91 / 80.04 and staged thresholds at 79.6 / 74.2 / 86.2 / 79.2. CLI layout/piece-command batch PR #112 Coverage measured 81.04 / 75.76 / 87.14 / 80.81 and staged thresholds at 80.3 / 75.1 / 86.6 / 80.2. CLI piece-registry batch PR #113 Coverage measured 82.30 / 77.02 / 88.60 / 82.08 and staged thresholds at 81.3 / 76.0 / 87.6 / 81.1. CLI summary-variant batch PR #114 Coverage measured 82.54 / 77.44 / 88.60 / 82.33 and staged thresholds at 81.8 / 76.5 / 87.9 / 81.6. CLI guide-output batch PR #115 Coverage measured 82.96 / 77.80 / 88.64 / 82.77 and staged thresholds at 82.2 / 77.0 / 88.0 / 82.0. CLI guide-render batch PR #116 Coverage measured 83.26 / 78.06 / 88.72 / 83.08 and staged thresholds at 82.5 / 77.4 / 88.1 / 82.4. CLI scenario/patrol batch PR #117 Coverage measured 83.98 / 78.47 / 89.18 / 83.82 and staged thresholds at 83.4 / 77.9 / 88.6 / 83.3. CLI declaration/piece batch PR #118 Coverage measured 84.40 / 78.82 / 89.29 / 84.24 and staged thresholds at 83.8 / 78.2 / 88.7 / 83.6. CLI readable command batch PR #119 Coverage measured 85.65 / 79.52 / 89.83 / 85.52 and staged thresholds at 84.8 / 79.1 / 89.4 / 84.8. CLI snapshot/piece batch PR #120 Coverage measured 86.17 / 80.32 / 90.02 / 86.07 and staged thresholds at 85.3 / 79.8 / 89.7 / 85.3. CLI reference generator script batch PR #121 Coverage measured 86.23 / 80.27 / 90.04 / 86.13 and staged thresholds at 85.7 / 79.8 / 89.7 / 85.7. Package-assets generator script batch PR #122 Coverage measured 86.48 / 80.44 / 90.09 / 86.38 and staged thresholds at 86.0 / 79.9 / 89.7 / 85.9. Packed consumer smoke orchestrator batch PR #123 Coverage measured 86.77 / 80.43 / 90.33 / 86.66 and staged thresholds at 86.2 / 80.0 / 90.0 / 86.2. Packed consumer types attestation batch PR #124 Coverage measured 86.81 / 80.41 / 90.38 / 86.70 and staged thresholds at 86.3 / 80.1 / 90.1 / 86.3. Packed consumer install smoke batch PR #125 Coverage measured 87.28 / 80.83 / 90.47 / 87.19 and staged thresholds at 86.7 / 80.5 / 90.2 / 86.7. Simulation engine defensive branch batch PR #126 Coverage measured 87.32 / 80.88 / 90.47 / 87.23 and stages thresholds at 86.8 / 80.6 / 90.3 / 86.8. Selectors edge-mask branch cleanup PR #127 Coverage measured 87.32 / 80.89 / 90.47 / 87.23 and stages thresholds at 86.8 / 80.7 / 90.3 / 86.8. Command handler branch batch PR #128 Coverage measured 87.37 / 80.98 / 90.47 / 87.28 and stages thresholds at 86.9 / 80.8 / 90.3 / 86.9. Ratchet against CI-measured merged coverage after each ≤200 LOC test batch; E8’s 100/100/100/100 flip is complete. NOTE: scenario.ts:1189 (spawn-group warning map) + 1204 (patrol warning map) effectively unreachable — spawn groups never emit warnings; patrol warning in patrol-route planning needs >1 waypoint + 0 segments (contradictory). Skip these arms.

  * World-rules system branch batch PR #129 Coverage measured 87.37 / 81.01 / 90.47 / 87.28, reached 100 / 100 / 100 / 100 for `src/systems/world-rules-system.ts`, and stages thresholds at 86.9 / 80.9 / 90.3 / 86.9.
  * Command-dispatch branch cleanup PR #130 Coverage measured 87.37 / 81.02 / 90.47 / 87.28, reached 100 / 100 / 100 / 100 for `src/systems/command-dispatch.ts`, and stages thresholds at 86.9 / 81.0 / 90.3 / 86.9.
  * Systems/runtime branch cleanup PR #131 Coverage measured 87.44 / 81.27 / 90.47 / 87.36, reached 100 / 100 / 100 / 100 for `src/systems/systems.ts`, `src/systems/events.ts`, `src/systems/tick.ts`, `src/runtime/asset-root.ts`, and `src/runtime/runtime.ts`, and staged thresholds at 87.0 / 81.1 / 90.3 / 87.0.
  * Simulation engine branch closure PR #132 Coverage measured 87.44 / 81.60 / 90.47 / 87.36, reached 100 / 100 / 100 / 100 for `src/simulation/engine.ts`, and staged thresholds at 87.0 / 81.2 / 90.3 / 87.0.
  * Script-validator branch cleanup PR #133 Coverage measured 87.44 / 81.73 / 90.47 / 87.36, reached 100 / 100 / 100 / 100 for `src/simulation/script-validators.ts`, and staged thresholds at 87.0 / 81.3 / 90.3 / 87.0.
  * Pieces branch cleanup PR #134 Coverage measured 87.44 / 81.80 / 90.47 / 87.36, reached 100 / 100 / 100 / 100 for `src/pieces/pieces.ts`, and staged thresholds at 87.0 / 81.4 / 90.3 / 87.0.
  * Occupancy branch cleanup PR #135 Coverage measured 87.44 / 81.81 / 90.47 / 87.36, reached 100 / 100 / 100 / 100 for `src/gameboard/occupancy.ts`, and staged thresholds at 87.0 / 81.5 / 90.3 / 87.0.
  * Manifest schema branch cleanup PR #136 Coverage measured 87.44 / 81.86 / 90.47 / 87.36, reached 100 / 100 / 100 / 100 for `src/manifest/schema.ts`, and staged thresholds at 87.0 / 81.6 / 90.3 / 87.0.
  * Catalog treatments branch cleanup PR #137 Coverage measured 87.44 / 81.89 / 90.47 / 87.36, reached 100 / 100 / 100 / 100 for `src/scenario/catalog-treatments.ts`, and staged thresholds at 87.0 / 81.7 / 90.3 / 87.0.
  * Catalog guide-data branch cleanup PR #138 Coverage measured 87.44 / 81.90 / 90.47 / 87.36, reached 100 / 100 / 100 / 100 for `src/scenario/catalog-guide-data.ts`, and staged thresholds at 87.0 / 81.8 / 90.3 / 87.0.
  * CLI/source-root branch cleanup PR #139 Coverage measured 88.25 / 82.55 / 91.27 / 88.19, reached 100 / 100 / 100 / 100 for `scripts/smoke/types.ts`, `src/cli/commands/bootstrap/target.ts`, `src/cli/commands/manifest.ts`, `src/cli/commands/validate.ts`, and `src/guides/simple-rpg/exercises.ts`; also closed branch gaps in `src/cli/commands/extract.ts`. Staged thresholds at 87.0 / 81.9 / 90.3 / 87.0.
  * Interop compatibility branch cleanup PR #140 Coverage measured 88.26 / 82.60 / 91.27 / 88.20, reached 100 / 100 / 100 / 100 for `src/interop/compatibility.ts` after KayKit tile placement, facing defaults, spawn fallback metadata, rigged default roles, idle/first animation fallback, and removal of an unreachable rigged-non-unit warning. Staged thresholds at 87.1 / 82.0 / 90.3 / 87.1.
  * CLI usage branch cleanup PR #141 Coverage measured 88.29 / 82.60 / 91.31 / 88.23, reached 100 / 100 / 100 / 100 for `src/cli/usage.ts` through direct import coverage of `HELP_TEXT` and `usage()`. Staged thresholds at 87.2 / 82.1 / 90.4 / 87.2.
  * Bootstrap upstream-layout cleanup PR #142 Coverage measured 88.31 / 82.62 / 91.31 / 88.25, reached 100 / 100 / 100 / 100 for `src/cli/commands/bootstrap/upstream-layout.ts` by covering the FREE-with-units rejection and removing redundant EXTRA units/nullish texture branches. Staged thresholds at 88.1 / 82.4 / 90.9 / 88.1.
  * CLI validate-plan exit cleanup PR #143 Coverage measured 88.37 / 82.64 / 91.42 / 88.29, reached focused 100 / 100 / 100 / 100 for `src/cli/commands/validate-plan.ts` by exercising the validation-error `process.exit(1)` path; merged report still carries a browser-map statement-id artifact for the same line. Staged thresholds at 88.2 / 82.5 / 91.0 / 88.2.
  * Gameboard terrain branch cleanup PR #144 Coverage measured 88.38 / 82.70 / 91.42 / 88.30, reached 100 / 100 / 100 / 100 for `src/gameboard/terrain.ts` by covering plan default fallbacks, same-order placement sort, custom tile tags, river crossing overlays, single-edge river masks, and sloped road overlays while removing unreachable internal terrain branches. Staged thresholds at 88.3 / 82.6 / 91.1 / 88.2.
  * CLI compatibility exit cleanup PR #145 Coverage measured 88.43 / 82.78 / 91.42 / 88.35, reached 100 / 100 / 100 / 100 for `src/cli/commands/compatibility.ts` by covering `--failOnWarning` warning exits and fatal bounds-error exits. Staged thresholds at 88.3 / 82.7 / 91.1 / 88.3.
  * CLI guide API/role cleanup PR #146 Coverage measured 88.46 / 82.84 / 91.42 / 88.39, reached 100 / 100 / 100 / 100 for `src/cli/commands/guide-apis.ts` and `src/cli/commands/guide-roles.ts` by covering empty selections, unfiltered API summary overflow, and removing unreachable selected-value/nullish and role truncation branches. Staged thresholds at 88.4 / 82.8 / 91.1 / 88.3.
  * CLI validate-recipe exit cleanup PR #147 Coverage measured 88.48 / 82.87 / 91.46 / 88.41, reached 100 / 100 / 100 / 100 for `src/cli/commands/validate-recipe.ts` by covering readable recipe validation errors and the fatal `process.exit(1)` branch. Staged thresholds at 88.4 / 82.8 / 91.2 / 88.4.
  * Coordinates projection cleanup PR #148 Coverage measured 88.50 / 82.93 / 91.46 / 88.43, reached 100 / 100 / 100 / 100 for `src/coordinates/projection.ts` by covering sloped road projection, river crossing projection, custom placement tie sorting, and removing unreachable projection defaults/helpers. Staged thresholds at 88.4 / 82.9 / 91.2 / 88.4.
  * Packed install smoke branch cleanup PR #149 Coverage measured 88.51 / 82.99 / 91.46 / 88.44, reached 100 / 100 / 100 / 100 for `scripts/smoke/pack-install.ts` by covering invalid pack metadata, missing plan/scenario count fallbacks, non-array SimpleRPG exercise evidence, and retained temp-app logging. Staged thresholds at 88.45 / 82.93 / 91.3 / 88.41.
  * CLI reference generator branch cleanup PR #150 Coverage measured 88.51 / 83.07 / 91.46 / 88.44, reached 100 / 100 / 100 / 100 for `scripts/generate-cli-reference.ts` by covering default generator option resolution, injected IO execution, direct-run predicate branches, and excluding only the thin executable entrypoint guard. Staged thresholds at 88.5 / 83.0 / 91.35 / 88.43.
  * SimpleRPG executable smoke branch cleanup PR #151 Coverage measured 88.55 / 83.11 / 91.54 / 88.47, reached 100 / 100 / 100 / 100 for `src/guides/simple-rpg/smoke.ts` by covering plan tile fallback/empty-plan failure, recipe error-count helpers, layout fill rule id fallback, and the FREE manifest asset lookup without the literal-key lint warning. Staged thresholds at 88.52 / 83.05 / 91.44 / 88.44.
  * Package-assets generator branch cleanup PR #152 Coverage measured 88.57 / 83.19 / 91.54 / 88.50, reached 100 / 100 / 100 / 100 for `scripts/generate-package-assets.ts` by covering default/injected dependency resolution, FREE/EXTRA write behavior, source-count failure, argument parsing, and the direct-run predicate while ignoring only the thin executable entrypoint guard. Staged thresholds at 88.55 / 83.14 / 91.5 / 88.46.
  * CLI snapshot branch cleanup PR #153 Coverage measured 88.61 / 83.21 / 91.58 / 88.53, reached 100 / 100 / 100 / 100 for `src/cli/commands/snapshot.ts` by covering invalid-plan validation exits, recipe compile failure after `allowInvalid`, stdout snapshot output, and plan/recipe/scenario option variants. Staged thresholds at 88.57 / 83.19 / 91.53 / 88.49.
  * CLI doctor/validate-manifest + scenario registry branch cleanup PR #154 Coverage measured 88.72 / 83.40 / 91.62 / 88.63, reached focused zero-miss coverage for `src/cli/commands/doctor.ts`, `src/cli/commands/validate-manifest.ts`, and `src/scenario/registry.ts` by covering coverage delegation, existing-source/missing-montage reporting, readable empty-manifest summaries, JSON output, fatal manifest validation issue exits, z-origin geometry warnings, terrainless manifest tile inference, default declaration asset/source normalization, object declaration application, custom placement kind defaults, and support-tile registry analysis while removing private unreachable layer/median guards. Staged thresholds at 88.64 / 83.28 / 91.56 / 88.54.
  * CLI guide-permutations/patrol-script branch cleanup PR #155 Coverage measured 88.83 / 83.50 / 91.70 / 88.74, reached focused zero-miss coverage for `src/cli/commands/guide-permutations.ts` and `src/cli/commands/patrol-script.ts` by covering manifest-backed missing permutation assets, readable missing-asset reporting, assignment-file array variants, missing-assignment validation, readable warning/error reporting, and fatal error/warning exits. Staged thresholds at 88.72 / 83.42 / 91.64 / 88.65.
  * Coordinates/quests branch cleanup PR #156 Coverage measured 88.89 / 83.67 / 91.70 / 88.78, reached 100 / 98.91 / 100 / 100 for `src/quests/quests.ts` and closed the remaining merged misses for `src/coordinates/coordinates.ts` by covering quest metadata/lookups, reach-tile pending progress, fallback progress preservation, source-less collision evaluation, non-quest entity rejection, canonical-key path reconstruction, spawn passability, and exported heap boundary cases while removing private unreachable coordinate/quest guards. Staged thresholds at 88.78 / 83.55 / 91.64 / 88.70.
  * CLI command-gap cleanup PR #157 Coverage measured 88.95 / 83.74 / 91.73 / 88.83, advanced `src/cli/commands` to 85.41 / 71.20 / 86.04 / 85.85 and `guide-usages.ts` to 100 / 92.30 / 100 / 100 by covering readable guide summaries, edition-scope and small-result filters, missing manifest asset exits, synthetic source-root extract/declarations success, doctor source reporting, and validation/compatibility fatal exits. Staged thresholds at 88.84 / 83.62 / 91.66 / 88.76.
  * CLI summarize-scenario cleanup PR #158 Coverage measured 88.98 / 83.88 / 91.73 / 88.86, reached 100 / 93.10 / 100 / 100 for `src/cli/commands/summarize-scenario.ts` by covering validation-error exits, allow-invalid readable summaries without a compiled board, warning-only `failOnWarning` exits, and readable title/top-asset/patrol summary fallbacks. Staged thresholds at 88.87 / 83.76 / 91.67 / 88.79.
  * Spawn-group/quest branch cleanup PR #159 Coverage measured 89.02 / 83.97 / 91.80 / 88.89, reached focused zero-miss coverage for `src/gameboard/spawn-groups.ts` by covering terrain/elevation/tag candidate filters, found/lower-cost/shorter/empty route selection, and removing unreachable route tie-key and warning-aggregate branches; removed the redundant quest metadata fallback after normalization and kept no-metadata quest spawn coverage. Staged thresholds at 88.90 / 83.86 / 91.74 / 88.82.
  * Command-handler branch cleanup PR #160 Coverage measured 89.02 / 84.11 / 91.80 / 88.89, reached focused zero-miss coverage for `src/commands/commands.ts` by covering source-less/unreachable/manual move previews, completed same-tile move execution, no-effect handler normalization, empty actor-target selection, single-handler presets, stale actor/placement removals, and successful placement removal while removing post-preview unreachable movement/handler defensive branches. Staged thresholds at 88.91 / 84.00 / 91.75 / 88.84.
  * Coverage merge location-key cleanup PR #161 Coverage measured 89.50 / 84.06 / 93.03 / 89.42, fixes cross-harness Istanbul statement/function/branch id and column drift by merging counters by source location with unique line fallback and ignoring zero-only unmatched browser entries. Staged thresholds at 89.10 / 84.00 / 92.00 / 89.00.
  * Dead built-CLI smoke cleanup PR #162 Coverage measured 91.81 / 85.47 / 94.01 / 91.81, removes stale unreferenced `scripts/smoke-built-cli.ts` after `test:cli` was deleted and rewrites current docs/commentary to the actual Vitest/coverage workflow. Staged thresholds at 91.50 / 85.30 / 93.80 / 91.50.
  * CLI entrypoint dispatcher PR #163 Coverage measured 92.55 / 85.85 / 95.60 / 92.57, reached 100 / 100 / 100 / 100 for `src/cli/cli.ts` through controlled side-effect imports with mocked `citty`, usage, and subcommand modules. Staged thresholds at 92.30 / 85.80 / 95.20 / 92.30.
  * Showcase promotion script PR #164 Coverage measured 93.07 / 85.96 / 95.88 / 93.07, reached 100 / 74 / 100 / 100 for `scripts/promote-showcases.ts` by extracting injected `promoteShowcases()`/`runPromoteShowcases()` helpers and covering check/promote/failure/quality paths. Staged thresholds at 92.80 / 85.85 / 95.65 / 92.80.
  * KayKit guide extractor PR #165 Coverage measured 93.57 / 86.22 / 96.32 / 93.60, reached 100 / 78.66 / 100 / 100 for `scripts/extract-kaykit-guide.ts` by extracting injected parser/runner/renderer helpers and covering Swift, portable, Windows lookup, missing-PDF, no-renderer, no-page, and command-failure paths. Staged thresholds at 93.30 / 86.10 / 96.00 / 93.30.
  * Spawn-groups command PR #166 Coverage measured 93.65 / 86.35 / 96.36 / 93.68 in CI (local reference-enabled proof read 94.01 / 86.68 / 96.55 / 94.03), reached 100 / 100 / 100 / 100 for `src/cli/commands/spawn-groups.ts` by covering missing `--groups`, validation-error exits, JSON output, spawn-plan error exits, and documenting the currently unreachable aggregate-warning exit. Staged thresholds at 93.50 / 86.30 / 96.30 / 93.50.
  * Blueprint command PR #167 local reference-enabled proof measured 94.33 / 87.35 / 96.74 / 94.34, advanced `src/cli/commands/blueprint.ts` to 98.33 / 93.47 / 90.90 / 99.14 by covering wrapped config parsing, CLI overrides, scenario/interop predicates, payload summaries, readable warnings, JSON output, warning exits, and scenario error exits; defensive output guards stay annotated because `shouldInspectBlueprintScenario` and `shouldEmitBlueprintInterop` make them unreachable through the public command flow. Staged thresholds at 93.90 / 86.90 / 96.40 / 93.90.
  * Guide-scenarios command PR #168 local reference-enabled proof measured 94.58 / 87.67 / 96.98 / 94.58, reached 100 / 93.10 / 100 / 100 for `src/cli/commands/guide-scenarios.ts` by covering guide filters, include-treatment payloads, missing-manifest asset reporting and exits, markdown stdout, JSON file output, invalid asset-scope errors, and the missing-treatment guard with restored fixture state. Staged thresholds at 94.20 / 87.20 / 96.60 / 94.20.
  * CLI shared-helper PR #169 local reference-enabled proof measured 95.06 / 88.12 / 97.17 / 95.08, advanced `src/cli/_shared.ts` to 87.86 / 83.16 / 94.12 by covering registry and piece-registry validation, output emission, GLTF metadata extraction, piece flag/source URL parsing, and readable helper reports. Staged thresholds at 94.60 / 87.70 / 96.80 / 94.60.
  * Patrol-routes command PR #170 local reference-enabled proof measured 95.15 / 88.27 / 97.21 / 95.17, advanced `src/cli/commands/patrol-routes.ts` to 95.83 / 90.90 / 100 / 95.74 by covering missing routes, malformed scenarios, validation exits, spawn-group exits, JSON and file output, scenario seed fallbacks, and route-error readable output. The remaining route warning/fail-on-warning arm depends on the documented contradictory route-planning warning path. Staged thresholds at 94.70 / 87.80 / 96.85 / 94.70.
  * Guide-assets command PR #171 local reference-enabled proof measured 95.25 / 88.45 / 97.36 / 95.25, reached 100 / 97.67 / 100 / 100 for `src/cli/commands/guide-assets.ts` by covering single-asset selected payloads, file output, readable small/overflow summaries, each empty-selection filter branch, and the no-match command error. Staged thresholds at 94.80 / 88.00 / 97.00 / 94.80.
  * Place-piece command PR #172 local reference-enabled proof measured 95.37 / 88.66 / 97.40 / 95.38, reached 100 / 97.29 / 100 / 100 for `src/cli/commands/place-piece.ts` by covering input validation, piece-registry selection failures, JSON/file/readable output, out-plan writes, invalid-plan exits, no-placement min-count exits, and seed/id-prefix placement output. The remaining coordinate-string readable branch is defensive because generated piece placements use coordinate objects. Staged thresholds at 94.90 / 88.10 / 97.10 / 94.90.
  * Analyze-layout command PR #173 local reference-enabled proof measured 95.48 / 88.88 / 97.44 / 95.49, reached 100 / 100 / 100 / 100 for `src/cli/commands/analyze-layout.ts` by covering input/rules validation, rule array and object parsing, file and CLI seed resolution, JSON/file/readable output, out-plan writes, invalid-plan exits, error exits, and fail-on-warning exits. Staged thresholds at 95.00 / 88.30 / 97.20 / 95.00.
  * Summarize-plan command PR #174 local reference-enabled proof measured 95.66 / 89.09 / 97.52 / 95.67, reached 100 / 100 / 100 / 100 for `src/cli/commands/summarize-plan.ts` by covering exact-input and JSON-shape validation, recipe/scenario compile exits, plan validation exits, validation warning exits, readable none/EXTRA top-asset branches, out/outPlan writes, and blueprint/config input aliases. Staged thresholds at 95.20 / 88.60 / 97.30 / 95.20.
  * Simulate-scenario command PR #175 local reference-enabled proof measured 95.82 / 89.41 / 97.59 / 95.83, reached 100 / 92.42 / 100 / 100 for `src/cli/commands/simulate-scenario.ts` by covering missing-input and malformed-scenario guards, scenario/script validation exits, JSON success and expectation-failure outputs, readable expectation-failure summaries, blocked-quest exits, and actor-target/mutation readable fallbacks. Staged thresholds at 95.30 / 88.90 / 97.40 / 95.30.
  * Piece command PR #176 local reference-enabled proof measured 95.85 / 89.54 / 97.59 / 95.86, reached 100 / 100 / 100 / 100 for `src/cli/commands/piece.ts` by covering missing-asset validation, derived asset and piece ids, default source and omitted role/report branches, explicit attribution/file output, warning exits, and fatal report error exits. Staged thresholds at 95.40 / 89.00 / 97.40 / 95.40.
  * Pieces command PR #177 local reference-enabled proof measured 95.91 / 89.68 / 97.59 / 95.92, reached 100 / 100 / 100 / 100 for `src/cli/commands/pieces.ts` by covering missing-input and conflicting placement-input validation, rule/source-url/placement payload variants, file output, registry analysis errors, registry warning exits, and placement-warning exits while marking the defensive placement-error guard unreachable because registry analysis blocks invalid selections before inspection. Staged thresholds at 95.45 / 89.10 / 97.40 / 95.45.
  * Bootstrap core PR #178 local reference-enabled proof measured 96.32 / 90.15 / 97.59 / 96.36, reached 100 / 100 / 100 / 100 for `src/cli/commands/bootstrap/core.ts` by covering default output resolution, same-size hash drift, non-empty targets without sidecars, malformed/oversized/escaping sidecars, source-format inclusion under the GLTF root, missing texture directories, deep/corrupt zip failures, successful mocked GitHub downloads, stream cleanup, and HTTP failure fallbacks; fixed extension parsing to use the file basename and marked only defensive library/filesystem race guards unreachable through the public zip path. Staged thresholds at 95.80 / 89.70 / 97.40 / 95.80.
  * Validate-simulation command PR #179 local reference-enabled proof measured 96.36 / 90.25 / 97.63 / 96.39, reached 100 / 100 / 100 / 100 for `src/cli/commands/validate-simulation.ts` by covering missing scenario/script guards, non-object scenario validation, JSON/readable output fallbacks with empty actor/quest lists, actor/quest JSON mapping, out-plan writes, and fatal script validation exits while simplifying redundant script-step array guards after `readSimulationScript` validation. Staged thresholds at 95.90 / 89.80 / 97.40 / 95.90.
  * Validate-scenario command PR #180 local reference-enabled proof measured 96.39 / 90.41 / 97.71 / 96.41, reached 100 / 100 / 100 / 100 for `src/cli/commands/validate-scenario.ts` by covering the missing-scenario guard, compiled-plan output, JSON/runtime actor and quest payloads, authored/empty fallback payloads when validation errors skip runtime creation, readable spawn/patrol summaries, and fatal validation exits while simplifying the unreachable runtime-plan fallback after inspection already compiles the plan. Staged thresholds at 96.00 / 89.90 / 97.40 / 96.00.
  * Pieces-from-assets command PR #181 local reference-enabled proof measured 96.57 / 90.74 / 97.75 / 96.60, reached 100 / 100 / 100 / 100 for `src/cli/commands/pieces-from-assets.ts` by covering missing inputs, no-model scans, override payload validation, single-file and multi-root asset inputs, absolute-path/includeReport payloads, prefix/tag file output, override-warning fail-on-warning exits, registry warning/error printing, and fatal registry-error exits while pairing scanned paths with source records and relying on the scanned-root invariant for relative asset paths. Staged thresholds at 96.10 / 90.20 / 97.40 / 96.10.
  * Guide-render-requests command PR #182 local reference-enabled proof measured 96.64 / 90.84 / 97.79 / 96.66, reached 100 / 100 / 100 / 100 for `src/cli/commands/guide-render-requests.ts` by covering empty selections, readable URL output, JSON grouped payloads, edition-scoped file output, missing manifest asset reporting, fatal missing-asset exits, and request overflow summaries. Staged thresholds at 96.20 / 90.30 / 97.40 / 96.20.
  * Guide-assets command PR #183 local reference-enabled proof measured 96.64 / 90.85 / 97.79 / 96.66, reached 100 / 100 / 100 / 100 for `src/cli/commands/guide-assets.ts` by removing the unreachable selected-asset nullish fallback after the `assetIdFilter.length === 1` guard. Staged thresholds at 96.20 / 90.40 / 97.40 / 96.20.
  * Summarize-scenario command PR #184 local reference-enabled proof measured 96.64 / 90.88 / 97.79 / 96.66, reached 100 / 100 / 100 / 100 for `src/cli/commands/summarize-scenario.ts` by covering readable EXTRA actor asset output, including the top-asset `*` suffix and non-empty actor extra asset list. Staged thresholds at 96.20 / 90.50 / 97.40 / 96.20.
  * CLI command-output PR #185 local reference-enabled proof measured 96.68 / 90.98 / 97.87 / 96.69, reached 100 / 100 / 100 / 100 for `src/cli/commands/place-piece.ts` and advanced `blueprint`, `patrol-routes`, and `simulate-scenario` command-output gaps through blueprint default-shape/error/warning/scenario-validation exits, readable actor-target and mutation output, and documented defensive display branches with no current public producer. Staged thresholds at 96.30 / 90.60 / 97.50 / 96.30.
  * CLI branch-artifact PR #186 local reference-enabled proof measured 96.69 / 91.08 / 97.87 / 96.70, reached 100 / 100 / 100 / 100 for `src/cli/commands/blueprint.ts`, `src/cli/commands/patrol-routes.ts`, and `src/cli/commands/simulate-scenario.ts` by covering the empty patrol-route display, JSON simulation report file output, and reducing redundant CLI blueprint numeric flag branches. Staged thresholds at 96.30 / 90.70 / 97.50 / 96.30.
  * Gameboard patrol-route PR #187 local reference-enabled proof measured 96.81 / 91.19 / 97.91 / 96.81, reached 100 / 100 / 100 / 100 for `src/gameboard/patrol-routes.ts` by covering explicit-start/default route diagnostics, open non-loop route warnings, route-set warning aggregation, and documenting public-path-unreachable waypoint-pair invariants. Staged thresholds at 96.40 / 90.80 / 97.50 / 96.40.
  * Gameboard navigation PR #188 local reference-enabled proof measured 96.92 / 91.37 / 97.95 / 96.91, reached 100 / 100 / 100 / 100 for `src/gameboard/navigation.ts` by covering blocked-start/blocked-goal path branches, reachability sorting and wrapper output, movement-cost fallbacks, malformed key diagnostics, and documented heap/map invariants maintained by the exported planners. Staged thresholds at 96.50 / 91.00 / 97.60 / 96.50.
  * Patrol runtime PR #189 local reference-enabled proof measured 96.97 / 91.57 / 97.99 / 96.96, reached 100 / 100 / 100 / 100 for `src/patrol/patrol.ts` by covering route snapshot sorting, current-waypoint fallbacks, blocked movement fallback context, resetless blocked movement requests, completed-route wrap/end states, missing-trait diagnostics, and sparse waypoint invariant errors while removing redundant post-normalization segment-cost fallback branching. Staged thresholds at 96.60 / 91.20 / 97.70 / 96.60.
  * Scenario branch cleanup PR #190 CI-measured merged proof measured 96.65 / 91.55 / 97.91 / 96.65, reached 100 / 95.95 / 100 / 100 for `src/scenario/scenario.ts` by covering collision objective tile targets, deep clone coverage for scenario metadata/navigation/agent options, actor asset aggregation, and documenting only public-path-unreachable spawn-resolution and warning diagnostics. Staged thresholds at 96.50 / 91.40 / 97.80 / 96.50.
  * Movement edge cleanup local merged proof measured 97.14 / 92.00 / 98.10 / 97.14, reached 100 / 98.18 / 100 / 100 for `src/movement/movement.ts` by covering stale completed paths, malformed sparse path diagnostics, newly blocked stale paths, missing board/placement state diagnostics, no-agent movement-budget fallback, and fixing movement-agent writes to add the trait when absent. Staged thresholds at 96.70 / 91.60 / 97.90 / 96.70.
  * Movement final branch cleanup local merged proof measured 97.14 / 92.02 / 98.10 / 97.14, reached 100 / 100 / 100 / 100 for `src/movement/movement.ts` by covering the idle path-state fallback and removing the unreachable entity-side missing-placement error branch. Staged thresholds at 96.70 / 91.65 / 97.90 / 96.70.
  * Showcase promotion branch cleanup local merged proof measured 97.14 / 92.18 / 98.10 / 97.14, reached 100 / 100 / 100 / 100 for `scripts/promote-showcases.ts` by covering default workspace/target/dependency fallbacks, promotion-mode runner success output, and `Error` quality analyzer reporting. Staged thresholds at 96.70 / 91.75 / 97.90 / 96.70.
  * KayKit guide extractor branch cleanup local merged proof measured 97.14 / 92.36 / 98.10 / 97.14, reached 100 / 100 / 100 / 100 for `scripts/extract-kaykit-guide.ts` by covering default dependency/repo-root fallbacks, process-platform command detection, non-`Error` runner failures, null Swift exit status fallback, and simplifying page-number sorting to the already-filtered filename invariant. Staged thresholds at 96.70 / 91.90 / 97.90 / 96.70.
  * Packed consumer smoke branch cleanup local merged proof measured 97.17 / 92.52 / 98.10 / 97.17, reached 100 / 100 / 100 / 100 for `scripts/smoke-packed-consumer.ts` by covering non-`Error` phase failures, default context/process/filesystem fallbacks, default runner dependency wiring on safe failure paths, and the injectable direct-run predicate while ignoring only the thin executable guard. Staged thresholds at 96.75 / 92.00 / 97.90 / 96.75.
  * Scenario final branch cleanup local merged proof measured 97.17 / 92.72 / 98.10 / 97.17, reached 100 / 100 / 100 / 100 for `src/scenario/scenario.ts` by covering unknown-id diagnostics, omitted scenario arrays/objectives, sparse navigation clone options, unresolved-summary actor copy variants, and removing redundant claimant/spawn-index invariant fallbacks. Staged thresholds at 96.75 / 92.20 / 97.90 / 96.75.
  * Scenario catalog branch cleanup local merged proof measured 97.25 / 92.83 / 98.22 / 97.25, reached 100 / 100 / 100 / 100 for `src/scenario/catalog.ts` by covering texture/faction/unit guards, empty edition-scope usage filters, Markdown option branches, missing-treatment usage/role-count behavior, and preserving default asset-id sort order. Staged thresholds at 96.80 / 92.30 / 98.00 / 96.80.
  * Ingest duplicate branch cleanup local merged proof measured 97.35 / 93.08 / 98.22 / 97.36, reached 100 / 100 / 100 / 100 for `src/ingest/ingest.ts` by covering missing manifest roots, manifest JSON output, duplicate asset-id suffix allocation, sparse GLTF metadata, optional texture discovery, unsupported categories, symlink skipping, and simplifying private fallback branches to the generated-manifest invariants. Staged thresholds at 96.90 / 92.60 / 98.00 / 96.90.
  * script-validators.ts 100 / 100 / 100 / 100; remaining simulation-surface gaps are in assertions/patrol/report-adjacent helpers, not authored-script validators.
  * engine.ts 100 / 100 / 100 / 100 — direct mutation defaults, patrol simulation route-set branch, actor-target default spreads, and unreachable koota placement-state fallbacks closed.
  * assertions.ts 100 / 100 / 100 / 100 — expectation branches and actor-target matching are zero-miss in merged coverage.
  * report.ts 100 / 100 / 100 / 100 — copyQuestObjective tile/targetTile branches done.
  * patrol.ts 100 / 100 / 100 / 100 — route sorting, blocked fallback context, completed wrap/end transitions, and malformed entity diagnostics closed.
  * layout.ts 87.13 → ratcheting; normalizeArchetypes, resolveArchetype, selectLayout count=0.
  * quests.ts merged zero-miss after metadata normalization cleanup; historical objective rollover coverage remains in place.
  * manifest/schema.ts 100 / 100 / 100 / 100 — unit-style exclusion plus malformed-id diagnostic fallback branches closed.
  * scenario/catalog-treatments.ts 100 / 100 / 100 / 100 — source-path sort tie plus fallback neutral-structure and prop treatment branches closed.
  * scenario/catalog-guide-data.ts 100 / 100 / 100 / 100 — private guide scenario input now requires authored public APIs instead of carrying an unreachable fallback.
  * scenario/catalog.ts 100 / 100 / 100 / 100 — public taxonomy guards, usage filter edges, Markdown option branches, missing-treatment guards, and asset-id sort behavior closed.
  * actors.ts 88.93 → register + navigationProfile action wrappers.
  * pieces.ts 100 / 100 / 100 / 100 — declaration asset defaults, pooled object-archetype checks, placement count fallbacks, and compatibility override tags closed.
  * scenario/scenario.ts 100 / 100 / 100 / 100 — clone/summary option branches, collision target tile validation, unknown scenario ids, optional quest objectives, allocator claimant labels, unset spawn indexes, omitted cloned navigation fields, and unresolved-summary actor copies closed.
  * gameboard.ts 92.21 → addUnitPreset role variants.
  * bootstrap.ts 75 → verifyBootstrap unsafe-sidecar + missing-file.
  * movement.ts 100 / 100 / 100 / 100 — stale completed paths, idle fallback, sparse path diagnostics, blocked stale paths, missing board/placement state diagnostics, no-agent budget fallback, and add-if-absent agent writes covered.
  * interop/compatibility.ts 100 / 100 / 100 / 100 — tile-compatible placement, facing defaults, spawn fallback metadata, rigged default roles, animation fallback chain, and unreachable rigged-non-unit warning removed.
  * cli/usage.ts 100 / 100 / 100 / 100 — direct import covers `HELP_TEXT`, console output, and requested exit code.
  * cli/commands/bootstrap/upstream-layout.ts 100 / 100 / 100 / 100 — FREE-with-units rejection covered; redundant EXTRA units and nullish texture fallback branches removed.
  * cli/commands/validate-plan.ts 100 / 100 / 100 / 100 — validation-error output plus `process.exit(1)` branch covered.
  * cli/commands/compatibility.ts 100 / 100 / 100 / 100 — warning and fatal error `process.exit(1)` branches covered.
  * cli/commands/guide-apis.ts 100 / 100 / 100 / 100 — empty selection, selected payload, and readable overflow summary covered.
  * cli/commands/guide-roles.ts 100 / 100 / 100 / 100 — empty selection and selected payload covered; fixed readable output to list all current roles instead of carrying unreachable overflow.
  * cli/commands/validate-recipe.ts 100 / 100 / 100 / 100 — readable validation errors plus fatal `process.exit(1)` branch covered.
  * coordinates/projection.ts 100 / 100 / 100 / 100 — sloped road/crossing projection, custom placement tie sort, and unreachable defaults/helpers closed.
  * gameboard/terrain.ts 100 / 100 / 100 / 100 — default plan fallbacks, placement tie sort, authored tags, river crossing/single-edge river overlays, and sloped road overlays covered; unreachable internal branches removed.
  * gameboard/spawn-groups.ts, gameboard/patrol-routes.ts, and gameboard/navigation.ts 100 / 100 / 100 / 100.
  * ingest.ts 100 / 100 / 100 / 100 — duplicate suffix allocation, sparse GLTF metadata, texture discovery, symlink skip, missing-root errors, and manifest JSON output covered; private fallback invariants simplified.
  * Browser branch-map cleanup batch local merged proof measured 97.35 / 93.16 / 98.22 / 97.36, reached merged zero-miss coverage for `src/coordinates/projection.ts`, `src/gameboard/terrain.ts`, and `src/simulation/engine.ts` by exercising river-crossing projection/terrain and direct simulation mutation system branches in Chromium while simplifying actor-update mutation reads to use the updated entity. Staged thresholds at 96.90 / 92.70 / 98.00 / 96.90.
  * Gameboard/validation branch cleanup local merged proof measured 97.61 / 93.74 / 98.21 / 97.62, reached merged zero-miss coverage for `src/gameboard/gameboard.ts` and `src/rules/validation.ts` by covering builder default/variant/boundary branches, invalid authored placement/connectivity validation diagnostics, EXTRA asset references, and declaration adjacency boundaries while documenting only current public-path-impossible fallback guards. Staged thresholds at 97.10 / 93.20 / 98.00 / 97.10.
  * Seeded rules branch cleanup local merged proof measured 97.78 / 94.10 / 98.29 / 97.80, reached merged zero-miss coverage for `src/rules/rules.ts` by covering seeded board defaults/degenerate shapes, density override exclusivity, piece-fill registry errors/empty selections/object archetypes, and option-level layout archetype fills while documenting deterministic built-in shape/path invariants. Staged thresholds at 97.30 / 93.60 / 98.10 / 97.30.
  * Recipe branch cleanup local merged proof measured 97.84 / 94.60 / 98.40 / 97.86, reached merged zero-miss coverage for `src/scenario/recipe.ts` by covering remaining serializable step dispatch and clone paths, raw malformed action diagnostics, empty/no-seed/piece-only generation, local/global archetype merges, and deep criteria footprint/distance/preference cloning while fixing `setTileAsset` recipe tag cloning. Staged thresholds at 97.40 / 94.10 / 98.20 / 97.40.
  * Koota branch cleanup local merged proof measured 98.00 / 94.96 / 98.52 / 98.03, reached merged zero-miss coverage for `src/koota/koota.ts` by covering stale placement-index collision recovery, trait-corruption error paths, sparse occupancy relations, equal-order placement/occupancy sorting, default layer dispatch, computed placement offsets, and invalid tile-key inspection while simplifying query-required placement state reads. Staged thresholds at 97.50 / 94.50 / 98.30 / 97.50.
  * Blueprint branch cleanup local merged proof measured 98.19 / 95.62 / 98.52 / 98.23, reached merged zero-miss coverage for `src/scenario/blueprint.ts` by covering tiny-board diagnostics, authored town/harbor/road/river fallback IDs, generated defaults, semantic prop-cluster dressing, bridge de-duplication, empty-shape ridge failures, and defensive blueprint compiler invariants. Staged thresholds at 97.70 / 95.10 / 98.30 / 97.70.
  * Three branch cleanup local merged proof measured 98.39 / 95.99 / 98.75 / 98.44, reached merged zero-miss coverage for `src/three/three.ts` by covering asset URL defaults, animation URL overrides and clip fallbacks, transform/framing helpers, recursive user-data tagging, interaction lookup misses, stale-removal branches, no-parent sync, and sync load error collection/rethrow paths. Staged thresholds at 97.90 / 95.50 / 98.50 / 97.90.
  * Interop branch cleanup local merged proof measured 98.53 / 96.84 / 98.79 / 98.58, reached merged zero-miss coverage for `src/interop/interop.ts` by covering base snapshot inclusion flags, spawn candidates, legacy adjacency relation fallback, missing relation target reporting, out-of-board footprint filtering, scenario inclusion flags, unresolved actor/quest relation skips, spawn/patrol planning errors, runtime snapshot inclusion flags, and simulation report fallback variants while documenting only public-path-impossible interop serialization invariants. Staged thresholds at 98.00 / 96.30 / 98.50 / 98.00.
  * Layout branch cleanup local merged proof measured 98.79 / 97.74 / 98.87 / 98.85, reached merged zero-miss coverage for `src/coordinates/layout.ts` by covering layout archetype fallback registries, custom/radius/adjacent footprints, harbor facing inference, fill diagnostics, default layers, sparse serialized plans, and fill/spawn default seeds while documenting only public-path-impossible analyzer and slot-angle invariants. Staged thresholds at 98.30 / 97.20 / 98.60 / 98.30.
  * Actors branch cleanup local merged proof measured 99.15 / 98.79 / 98.99 / 99.23, reached merged zero-miss coverage for `src/actors/actors.ts` by covering actor kind inference, selector/string fallbacks, collision profiles, neighborhood aggregation, interaction command edges, actor-target sorting, disconnected target paths, and documenting only public-path-impossible ECS corruption/route sentinel invariants. Staged thresholds at 98.60 / 98.30 / 98.80 / 98.70.
  * CLI shared-helper cleanup local merged proof measured 99.65 / 99.57 / 99.18 / 99.75, reached 100 / 100 / 100 / 100 for `src/cli/_shared.ts` by covering manifest/registry validation, synthetic source manifest generation, plan reader exits, patrol route-set fallbacks, GLB metadata chunks, piece selection/source branches, and readable report edge cases while simplifying only guarded route and asset-id fallbacks. Staged thresholds at 99.30 / 99.20 / 99.00 / 99.40.
  * React cleanup local merged proof measured 100 / 100 / 100 / 100, reached merged zero-miss coverage for `src/react/react.ts` by covering provider factories, action-hook factories, empty-world fallbacks, coordinate-object tile hooks, queued revision disposal, and browser interop spawn-location merge counters while simplifying only unreachable/internal option guards. Remaining gaps: none in merged coverage. The explicit `script.ts`, `script-validators.ts`, bootstrap core, `gameboard/gameboard.ts`, `rules/validation.ts`, `rules/rules.ts`, `scenario/recipe.ts`, `scenario/blueprint.ts`, `koota/koota.ts`, `three/three.ts`, `interop/interop.ts`, `coordinates/layout.ts`, `actors/actors.ts`, `cli/_shared.ts`, and `react/react.ts` gaps are closed.

* [x] \[DONE] **E0h** — Sweep remaining src/ files to 100% (paired with E0a per-PR). PR#10 closures advanced many of these in tandem with E0a. Status post-merge:

  * `pieces/pieces.ts` 100 / 100 / 100 / 100 in focused and merged unit coverage after declaration defaults, pooled-rule compatibility, placement fallback, and override-tag branch closure
  * `gameboard/occupancy.ts` 100 / 100 / 100 / 100 in merged coverage after explicit layout-footprint opt-out branch closure
  * `quests/quests.ts` merged zero-miss after metadata normalization cleanup; quest objective rollover + reward dispatch coverage remains in the existing slices
  * `actors/actors.ts` 100 / 100 / 100 / 100 in focused and merged coverage after actor kind inference, selector/string fallbacks, collision profiles, neighborhood aggregation, interaction command edges, actor-target sorting, disconnected target paths, and defensive ECS/route invariant cleanup.
  * `scenario/scenario.ts` 100 / 100 / 100 / 100 in merged coverage after unknown-id diagnostics, omitted scenario arrays/objectives, sparse navigation clone options, unresolved-summary actor copy variants, and invariant fallback cleanup
  * `scenario/blueprint.ts` 100 / 100 / 100 / 100 in merged coverage after tiny-board diagnostics, authored fallback ids/defaults, semantic prop-cluster dressing, bridge de-duplication, and defensive compiler invariants
  * `scenario/catalog.ts` 100 / 100 / 100 / 100 in merged coverage after public taxonomy guards, usage filter edges, Markdown option branches, missing-treatment guards, and asset-id sort behavior
  * `ingest/ingest.ts` 100 / 100 / 100 / 100 in merged coverage after duplicate suffix allocation, sparse GLTF metadata, texture discovery, symlink skip, missing-root errors, and manifest JSON output
  * `manifest/schema.ts` 100 / 100 / 100 / 100 in merged coverage after manifest normalization/filter combinations
  * `gameboard/navigation.ts` 100 / 100 / 100 / 100 in merged coverage after pathfinding and reachability edge branches
  * `coordinates/layout.ts` 100 / 100 / 100 / 100 in merged coverage after layout archetype fallback registries, custom/radius/adjacent footprints, harbor facing inference, fill diagnostics, default layers, sparse serialized plans, and fill/spawn default seed branch coverage.
  * `three/three.ts` 100 / 100 / 100 / 100 in merged coverage after URL fallback, animation fallback, transform/framing helper, user-data lookup, and sync error/stale branch coverage.
  * `interop/interop.ts` 100 / 100 / 100 / 100 in merged coverage after snapshot option, relation fallback, scenario/runtime/simulation projection, and defensive serialization invariant coverage.
  * `cli/_shared.ts` 100 / 100 / 100 / 100 in merged coverage after manifest/registry validation, synthetic source manifest generation, plan reader exits, patrol route-set fallbacks, GLB metadata chunks, piece selection/source branches, and readable report edge cases.
  * `react/react.ts` 100 / 100 / 100 / 100 in merged coverage after provider/action hook factories, empty-world fallbacks, coordinate-object tile helpers, queued revision disposal, and browser interop spawn-location counter closure.
  * `scenario/recipe.ts` merged zero-miss after serializable step dispatch and clone branch coverage, empty/no-seed/piece-only generation coverage, local/global archetype merge coverage, malformed action diagnostics, and `setTileAsset` tag clone hardening.
  * `patrol/patrol.ts` 100 / 100 / 100 / 100 in merged coverage after route snapshot sorting, blocked context fallbacks, completed-route wrap/end states, and malformed trait diagnostics.
  * `src/cli/commands/{blueprint,summarize-plan,snapshot,spawn-groups,patrol-routes}.ts` advanced by a direct-import blueprint-derived command batch; `src/cli/_shared.ts` advanced by guide-filter, authored-option, piece-source-root, and scalar-helper coverage; `validate-plan`, `validate-recipe`, `validate-scenario`, `validate-simulation`, and `summarize-scenario` advanced by docs-fixture happy paths; `simulate-scenario` and `patrol-script` advanced by report/output happy paths; `validate-manifest`, `analyze-layout`, and `place-piece` advanced by docs/blueprint fixture success paths; `doctor` and `validate-manifest` reached focused 100 / 100 / 100 / 100 through coverage delegation, existing-source/missing-montage reporting, readable empty-manifest summaries, JSON output, and fatal manifest validation issue exits; `scenario/registry.ts` reached focused zero-miss coverage through z-origin geometry warnings, terrainless manifest tile inference, default declaration asset/source normalization, object declaration application, custom placement kind defaults, and support-tile registry analysis; `pieces-from-assets` and `pieces` advanced by local GLTF fixture registry/rules/source URL paths; `summarize-plan`, `patrol-routes`, `validate-scenario`, `validate-simulation`, and `summarize-scenario` advanced through recipe/scenario/blueprint input variants and JSON/output paths; `guide-assets`, `guide-roles`, `guide-scenarios`, and `guide-usages` advanced through filtered file output, markdown output, and readable summaries; `guide-apis`, `guide-permutations`, and `guide-render-requests` advanced through filtered file output, grouped render requests, asset-base URLs, and readable summaries; `summarize-scenario`, `patrol-routes`, and `patrol-script` advanced through readable summaries, assignment-file variants, and malformed payload guards; `declarations`, `analyze`, `compatibility`, and `piece` advanced through packaged-manifest output, readable analysis, synthetic GLTF compatibility, and piece declaration output; readable command-output variants advanced `summarize-plan`, `validate-plan`, `validate-recipe`, `validate-scenario`, `validate-simulation`, `spawn-groups`, `analyze-layout`, and `place-piece` through readable report paths; `blueprint`, `snapshot`, `pieces-from-assets`, and `pieces` advanced through readable blueprint/scenario inspection, plan/recipe snapshot variants, GLTF asset scans, registry analysis, rules, source URLs, and piece-fill placement output. `scripts/smoke/pack-install.ts` advanced through dependency-injected packed install, CLI assertion, temp-write, and generated source coverage. The larger CLI command surface still has low-coverage command modules. Each file’s continuation work lands as one commit that adds ≤200 LOC of test code and ratchets the floor.

* [x] \[DONE] **E8** — Flip coverage thresholds to **100 / 100 / 100 / 100** in `vitest.coverage.shared.ts`. Final React cleanup local merged Coverage proof is 100 / 100 / 100 / 100 and the remaining `react/react.ts` gap is closed.

### Phase E-MergedGate — wire browser coverage into the enforced gate

[Section titled “Phase E-MergedGate — wire browser coverage into the enforced gate”](#phase-e-mergedgate--wire-browser-coverage-into-the-enforced-gate)

**User decision (2026-05-28):** the enforced CI gate (`test:coverage:enforce`) is unit-only, but it measures `src/react/react.ts` + `src/three/three.ts` which Node can never cover (292 uncov lines / 134 uncov fns dragging the gate \~1.5–4pt). Chosen fix: **wire browser-free coverage into the gate** (merge unit + browser-free, enforce on merged) so react/three are measured where they CAN be covered — NOT exclude them.

Closeout (2026-06-25):

1. **\[DONE]** Stale browser alias/import safety work from LF8 remains green; `tests/unit/umbrella-browser-safe.test.ts` asserts zero `node:*` leaks from the umbrella.
2. **\[DONE]** Vitest Browser hang fixed: `publicDir: packageRoot` was shadowing Vitest Browser’s client; browser-free now uses `publicDir: false`, serves bootstrapped GLTFs through `/@fs/<repo>/models`, and has an explicit `@vitest/runner` dev dependency plus browser harness smoke coverage.
3. **\[DONE]** Local visual gate is green: `pnpm exec tsx src/cli/cli.ts bootstrap --source github --out models`; `pnpm test:browser:free`.
4. **\[DONE]** Merged coverage gate is enforced: `scripts/merge-coverage.ts` runs `nyc check-coverage` when `HEX_WORLDS_COVERAGE_ENFORCE=1`; `pnpm coverage:all:enforce` passed locally at 78.19 / 72.18 / 86.11 / 77.94 and `.github/workflows/ci.yml` Coverage now bootstraps FREE models, installs Playwright Chromium, and enforces the merged unit+browser-free tree.

**Layering decisions (2026-05-28, user-directed during link-3 investigation):**

* The 1100-line root `src/index.ts` hand-relisted 956 named symbols that the 18 domain barrels already `export *` — pure duplication, not curation (tiering is enforced at package.json#exports + @internal, not the root hand-list). **Root rewritten to barrel-forwarding** (`export * from './<domain>'`). Adding a public export to a domain now needs no root edit.
* There is **NO server/browser split and NO `server.ts`** (rejected as a wrapper shim). The umbrella is browser-safe by *correct layering*: it exports library/runtime API only. `bootstrap` is a **CLI-domain capability** (reachable ONLY from `src/cli/`; never from runtime/react/three) — it was wrong to re-export it from the umbrella at all. Bootstrap stays reachable via the `./bootstrap` subpath for programmatic CLI-equivalent callers.
* `manifest/upstream-layout.ts` was **mis-filed**: its data + fs-probers are consumed ONLY by bootstrap (CLI-domain), nothing in manifest/runtime uses it. **Move `src/manifest/upstream-layout.ts` → `src/bootstrap/upstream-layout.ts`**; published subpath renamed `./manifest/upstream-layout` → `./bootstrap/upstream-layout` (pre-1.0; update docs-site 3 refs + smoke/types.ts + architecture table + biome restricted-imports + tsup entry + package.json exports). bootstrap barrel re-exports it.

**Ordered sequence:** The LF batch below remains the historical decomposition that unblocked browser-safe imports. Step C and Step D are complete as of 2026-06-25; the remaining coverage work is E0a/E0h/E8’s progressive 100% ratchet, not the browser/merge gate itself.

## Batch — library-fit-decomposition (batch-20260528-103351)

[Section titled “Batch — library-fit-decomposition (batch-20260528-103351)”](#batch--library-fit-decomposition-batch-20260528-103351)

Source: docs/plans/library-fit-decomposition.prq.md (sha256: 42bbb50d5a7041055a2a67438c99192629f0f2264f89871989985fdb892d6f96) Started: 2026-05-28T10:33:51Z

### task-LF1 Barrel-forwarding umbrella + internal extraction (merged LF1+LF1b)

[Section titled “task-LF1 Barrel-forwarding umbrella + internal extraction (merged LF1+LF1b)”](#task-lf1-barrel-forwarding-umbrella--internal-extraction-merged-lf1lf1b)

* [x] task-LF1 ✅ (commit, 2026-05-28) Rewrite src/index.ts to `export * from './<domain>'` only (18 library barrels); drop bootstrap re-exports. Extract the 28 internal helpers the barrels over-export so they’re shareable-but-private:

  * DISCOVERY (2026-05-28): the old hand-list root was NOT pure duplication — it curated OUT 28 internal helpers the domain barrels over-export via `export *`. Barrel-forwarding surfaces them; they must leave the public boundary.

  * **Generic cross-cutting → new `src/internal/` (NOT in package.json#exports):** errorMessage, isNonEmptyString, isRecord (dedupe the cli/\_shared.ts copy too), includesString, isHexCoordinatesInput, tryParseHexKey, plus the type-guards/const-arrays that are pure utilities.

  * **Domain-specific internals stay in their domain file but leave the public boundary** (the barrel/shim re-exports only public names; siblings import directly): report.ts internals (actorRecord/…/simulationResult), script.ts SIMULATION\_\* arrays + isSimulation\* guards + tileKeyFromTargetInput, gameboardPlanIndex\@gameboard, isTextureSet/isUnitStyle\@catalog, readValidationGameboardPlanFromWorld\@projection, GAMEBOARD\_RELEASE\_GATE\_SUMMARIES + GAMEBOARD\_REQUIRED\_BROWSER\_SCREENSHOT\_ARTIFACTS\@coverage, KAYKIT\_ATTRIBUTION\@schema.

  * Mechanism: where a shim/barrel does `export *` and must drop internals, either move internals to `src/internal/` (generic) or convert that shim to public-named re-exports (domain-specific). Update all importers + biome noRestrictedImports for `../internal`. typecheck + unit green.

  * **CONTRACT DECISION (2026-05-28, user: “pick the BEST for the library”):** umbrella = union of legitimately-public subpath symbols; genuinely-internal symbols leave ALL public surfaces. The old hand-list was a curated-subset (umbrella ⊊ subpaths) — that was WRONG for symbols with real external consumers. Classification of the post-barrel-forwarding leaks:

    * **Move to internal (no external consumer; only cross-file impl detail; auto-typedoc is noise):** `actorRecord`/`placementRecord`/`simulationResult`/`actorTargetsRecordFromReport`/`emptyActorTargetsRecord` (report↔engine) → `src/simulation/internal.ts`; `tryParseHexKey` (coordinates-internal) → `src/internal` or private; `gameboardPlanIndex` (cross-domain layout/interop/gameboard impl) → `src/internal`; `GAMEBOARD_RELEASE_GATE_SUMMARIES` (coverage-internal) + `GAMEBOARD_REQUIRED_BROWSER_SCREENSHOT_ARTIFACTS` (coverage→cli impl) → `src/internal` or interop-internal.
    * **Keep public — real external consumers, umbrella SHOULD expose (old list wrongly omitted):** `KAYKIT_ATTRIBUTION` (scripts/audit-package.ts) ; `readValidationGameboardPlanFromWorld` (scripts/smoke/\*). These were already public on their subpath; accept into umbrella, add to snapshot.
    * Final snapshot diff = bootstrap (13) + all genuine internals removed; + KAYKIT\_ATTRIBUTION + readValidationGameboardPlanFromWorld + any other real-consumer symbols added. Delete stale auto-typedoc pages for the now-internal symbols (docs-site reference regen).

  * **PROGRESS (2026-05-28):** umbrella → barrel-forwarding DONE. src/internal/predicates.ts (5 generic) DONE. src/simulation/internal.ts (SIMULATION\_\* arrays + isSimulation\* guards + tileKeyFromTargetInput) DONE — cycle broken by owning STEP\_ACTIONS in internal.ts. simulation.ts shim curated (report records omitted) DONE. tsc green, 714/715 unit pass, ONLY public-api snapshot red.

  * **REMAINING 6 leaks + decisions:** KEEP-PUBLIC (real consumers, accept into snapshot): `KAYKIT_ATTRIBUTION` (scripts/audit-package), `readValidationGameboardPlanFromWorld` (scripts/smoke). MOVE-INTERNAL via per-domain shim/barrel curation (same pattern as simulation.ts): `tryParseHexKey` (coordinates.ts-internal, used by parseHexKey), `gameboardPlanIndex` (gameboard.ts, cross-domain → coordinates/interop import it; curate gameboard barrel + give cross-domain callers a path — likely `src/internal` re-home accepting type-only domain imports, OR a gameboard/internal.ts with a biome exception), `GAMEBOARD_RELEASE_GATE_SUMMARIES` (coverage.ts-internal), `GAMEBOARD_REQUIRED_BROWSER_SCREENSHOT_ARTIFACTS` (coverage.ts → cli consumes; cross-domain). Then update snapshot, delete stale typedoc pages, biome rule for any new internal import paths. typecheck + unit + coverage green → commit LF1. **REORDER (2026-05-28, forward self-assessment after LF1):** LF2 (config extraction) was originally first, but the work surfaced that its content — the KAYKIT\_FREE\_GITHUB\_\* constants + repo-clone patterns — is downstream of LF7’s git-clone decision (github→git changes those constants’ semantics entirely) AND lives in bootstrap files that LF4 relocates. Extracting config now would build a schema LF7 then reshapes. BEST order: **LF3 → LF4 → LF7 → LF2 → LF5 → LF6 → LF8** so config captures the SETTLED constants (incl. git-clone patterns) from their final home. (Per “pick the BEST, let work surface the next step”.)

### task-LF2 src/config JSON config domain (reordered: after LF7)

[Section titled “task-LF2 src/config JSON config domain (reordered: after LF7)”](#task-lf2-srcconfig-json-config-domain-reordered-after-lf7)

* [x] task-LF2 ✅ (commit, 2026-05-28) Created src/config/ with 3 JSON files (kaykit-source, bootstrap-paths, upstream-layouts) + typed loader (`KAYKIT_SOURCE`, `BOOTSTRAP_PATHS`, `UPSTREAM_LAYOUTS`, `kaykitGithubArchiveUrl`). Migrated all KAYKIT\_BOOTSTRAP\_*, KAYKIT\_FREE\_GITHUB\_*, KAYKIT\_FREE\_USER\_AGENT, KAYKIT\_\*\_EXTENSIONS, KAYKIT\_SIDECAR\_SCHEMA\_VERSION, KAYKIT\_MEDIEVAL\_FREE/EXTRA\_LAYOUT to derive from config. Public names unchanged, browser-safe (pure JSON, no node), internal (not in exports). All green.

### task-LF3 Relocate upstream-layout

[Section titled “task-LF3 Relocate upstream-layout”](#task-lf3-relocate-upstream-layout)

* [x] task-LF3 ✅ (commit, 2026-05-28) Moved src/manifest/upstream-layout.ts → src/bootstrap/upstream-layout.ts (whole file; config extraction of its data deferred to reordered LF2). manifest barrel drops it; bootstrap barrel re-exports. Subpath renamed manifest/upstream-layout → bootstrap/upstream-layout (tsup+package.json+smoke+astro typedoc). 6 layout symbols left umbrella (→ ./bootstrap). Also: react/three added to umbrella (LF1 follow-up, invariant #5, commit `3461858`). All green: typecheck/715 unit/build/lint.

### task-LF4 Relocate bootstrap to CLI command area

[Section titled “task-LF4 Relocate bootstrap to CLI command area”](#task-lf4-relocate-bootstrap-to-cli-command-area)

* [x] task-LF4 ✅ (commit, 2026-05-28) Moved src/bootstrap/\* → src/cli/commands/bootstrap/ (core/target/upstream-layout/index.ts; index now hosts the `run` command merging the old thin wrapper). \_shared imports `./commands/bootstrap/core` (cycle-safe). tsup + astro typedoc inputs repointed; subpath KEYS + dist paths unchanged. e2e/integration tests repointed. No top-level src/bootstrap/. All green: typecheck/715 unit/build/lint.

### task-LF5 Repoint subpaths + build + lint + docs

[Section titled “task-LF5 Repoint subpaths + build + lint + docs”](#task-lf5-repoint-subpaths--build--lint--docs)

* [x] task-LF5 ✅ (commit, 2026-05-28) Hand-written docs repointed (architecture, errors guide, kaykit-upstream-layout guide). Auto-typedoc regenerated. Empty stale `reference/bootstrap/` deleted. biome rule needed no change (bootstrap moved INTO src/cli/commands; the rule’s `../bootstrap` matchers no longer apply since there’s no top-level bootstrap domain). package.json exports + tsup + scripts/smoke + astro typedoc inputs already updated in LF3+LF4. All green.

### task-LF6 Proper CLI library

[Section titled “task-LF6 Proper CLI library”](#task-lf6-proper-cli-library)

* [x] task-LF6 ✅ (commit, 2026-05-28) Adopted citty for command routing + lazy subcommand loading; hand-curated `./usage` preserved for `--help` (intercept BEFORE runMain since citty auto-help only lists subcommand names). All 35 subcommands unchanged (kept run(parsed, sourceRoot, edition) contract; citty wraps each with ctx.rawArgs → parseFlags). Lazy import per command preserves the cold-start budget. 31 cli tests pass; all green.

### task-LF7 Unify bootstrap source on the zip flow (no git, no peer dep)

[Section titled “task-LF7 Unify bootstrap source on the zip flow (no git, no peer dep)”](#task-lf7-unify-bootstrap-source-on-the-zip-flow-no-git-no-peer-dep)

* [x] task-LF7 ✅ (commit `644862c`, 2026-05-28) Unified: github source downloads the stable `/archive/refs/heads/main.zip` then reuses `stageFromZip` (same detector handles itch.io `<pack>/Assets/gltf` + github `<repo>-main/addons/kaykit_.../Assets/gltf`). Removed tar/gunzip/stream-pipeline + `tar` runtime dep + `.gz` ext. Verified structures via download. All green. ORIGINAL: **REVISED (user, 2026-05-28):** isomorphic-git rejected as overkill. The GitHub archive URL `https://github.com/KayKit-Game-Assets/KayKit-Medieval-Hexagon-Pack-1.0/archive/refs/heads/main.zip` is stable and never changes. Collapse the two source modes into ONE flow: the CLI accepts a local zip path and auto-detects free/extra by expected structural alignment (via the layout detector); if no zip is given, it fetches that stable archive .zip and feeds the SAME zip-extract flow (FREE only). Remove the tarball/gunzip/tar machinery (`node:zlib`, `node:stream/promises`, `tar` dep, `kayKitFreeGithubTarballUrl`’s codeload tar.gz URL → archive .zip URL). Keep the existing `openHttpsStream` redirect handling (github archive → codeload redirect) but pipe to a temp `.zip` file then reuse `stageFromZip`. Verify via `tree` that a fresh download of that zip extracts to the same structure as the FREE `references/` tree; support both structures if they differ. Drop `tar` runtime dep. Coverage for the unified path. typecheck+unit+build+lint green.

### task-LF8 Browser-import-safety verification

[Section titled “task-LF8 Browser-import-safety verification”](#task-lf8-browser-import-safety-verification)

* [x] task-LF8 ✅ (commit, 2026-05-28) Static-graph guard `tests/unit/umbrella-browser-safe.test.ts` walks src/index.ts transitive imports + asserts ZERO `node:*` leaks (72 files visited, 0 leaks). 2026-06-25 empirical verification: browser-free React/Three visual suites load under Chromium, `pnpm test:browser:free` passes with screenshot QA, and `pnpm coverage:all:enforce` measures the merged unit+browser-free tree.

### Phase E9 — visual integration gate (continuation)

[Section titled “Phase E9 — visual integration gate (continuation)”](#phase-e9--visual-integration-gate-continuation)

* [x] **E9** — ✅ Browser visual integration gate closed (2026-06-25). `tests/browser/free-visual.test.ts`, `simple-rpg-visual.test.ts`, and `feature-gallery.spec.ts` render the Three-backed catalog/gameboard/example surfaces into Chromium and assert committed PNG artifacts under `tests/browser/__screenshots__/`; `tests/browser/react-bindings.test.ts` exercises React hooks/providers/actions in Chromium; `tests/browser/browser-harness-smoke.test.ts` catches Vitest Browser client regressions. Local proof: `pnpm exec tsx src/cli/cli.ts bootstrap --source github --out models`; `pnpm test:browser:free`; `pnpm coverage:all:enforce`.

### Phase F-Site — docs-site continuation

[Section titled “Phase F-Site — docs-site continuation”](#phase-f-site--docs-site-continuation)

* [x] **F-Audit-7b-equiv** — ✅ Migrated all six `docs/guides/*.md` legacy files into `docs-site/src/content/docs/guides/` with canonical-URL redirect notes pointing back. The legacy `docs/guides/*.md` files stay (load-bearing in `src/scenario/catalog.ts` at lines 1366/1515/1557/1571/1614/1653/1673) with a top-of-file canonical pointer; the docs-site versions are the human-facing canonical with Starlight frontmatter. Six files: guide-scenario-coverage, public-api, recipes-scenarios-and-simulation, release-readiness, rendering-assets-and-external-packs, runtime-integration.

## Phase CR — Comprehensive Review Action Queue (2026-05-28)

[Section titled “Phase CR — Comprehensive Review Action Queue (2026-05-28)”](#phase-cr--comprehensive-review-action-queue-2026-05-28)

Findings from full 5-phase review (`.full-review/05-final-report.md`). Ordered by priority: P0 must ship before next release; P1 before next release but can batch; P2 sprint-level; P3 backlog.

### P0 — Critical (must fix before next release)

[Section titled “P0 — Critical (must fix before next release)”](#p0--critical-must-fix-before-next-release)

* [x] **CR-P0-1** — ✅ PR #62 (2026-05-28): main branch protection enabled via `gh api` with required checks: lint/typecheck/build/test/Coverage/Docs Site Build/Semgrep SAST/Dependency Review.
* [x] **CR-P0-2** — ✅ PR #62 (2026-05-28): Removed `release-as: "1.0.0"` from `release-please-config.json`.
* [x] **CR-P0-3** — ✅ PR #62 (2026-05-28): react/three/koota/react-dom → peerDependencies (optional); @types/react → devDependencies; citty/honeycomb-grid/seedrandom/yauzl stay as runtime deps.
* [x] **CR-P0-4** — ✅ (2026-05-28) Added `src/cli/commands/bootstrap/__tests__/security.test.ts` with 6 tests: (a) redirect allowlist — non-allowlisted host rejected, allowlisted host accepted (objects.githubusercontent.com → 503 proves 2nd hop ran), redirect depth >5 rejected; (b) zip-slip — raw-binary zip with `../../../` entry name rejected by extractZipTo; (c) zip-bomb — declared uncompressedSize > 64 MB rejected by pre-check, at-limit (=64 MB) passes pre-check but fails yauzl size-mismatch. Uses `vi.mock('node:https')` + raw zip buffer construction (yazl rejects `../` names). All 6 pass; lint/typecheck/test green.
* [x] **CR-P0-5** — ✅ PR #62 (2026-05-28): `readJson<T>` → `readJson(): unknown`; \~25 call sites updated with explicit `as X` casts; two unvalidated plan-return paths (layoutAnalysisPlanFromArgs, summaryPlanFromArgs) now run validateGameboardPlan; null/primitive guards added to readRegistry, readPieceRegistry, pieceOverridesFromArgs. Remaining: `readValidatedJson` wrapper + file-size ceiling + error-contract tests — tracked as CR-P1-partial below.

### P1 — High (fix before next release, can batch)

[Section titled “P1 — High (fix before next release, can batch)”](#p1--high-fix-before-next-release-can-batch)

* [x] **CR-P1-1** — ✅ (2026-05-29) Added 9 golden-path oracle tests (`pathfinding-oracle.test.ts`) pinning correctness + visit-count ceilings. Replaced O(N) `lowestScoreKey` + Set open-list in `findHexPath` with binary min-heap A\* (lazy deletion via g-cost mismatch). Replaced O(N) `lowestCostKey` in `reachableGameboardTiles` with binary min-heap Dijkstra. Zero new deps. Biome `noNonNullAssertion` satisfied via explicit undefined checks. PR #65.
* [x] **CR-P1-2** — ✅ (2026-05-29) Created `src/guides/simple-rpg/` (types/exercises/smoke/index.ts). Moved types + catalog + smoke to production; CLI imports `../guides/simple-rpg` + passes `scenarioJson as GameboardScenario`; test file re-exports production module + zero-arg wrapper. `_shared.ts` no longer imports from `tests/`. PR #66.
* [x] **CR-P1-3** — ✅ (2026-05-28) Fixed SAFE\_REF regex in config/index.ts: original `/^[a-zA-Z0-9._\-/]{1,200}$/` allowed `../../etc/passwd` (dots+slashes in charset); replaced with `/^(?!.*\.\.)(?!\.)(?!.*\/$)[a-zA-Z0-9._\-/]{1,200}$/` rejecting `..` sequences, leading dots, trailing `/`. Added CWE-74 guard test in smoke.test.ts; fixed security.test.ts typecheck (3× `as unknown as ReturnType<typeof request>` + headers cast). All 67 test files pass; tsc exit 0; lint clean.
* [x] **CR-P1-4** — ✅ (2026-05-29) Added `WeakMap<World, Map<string, Entity>>` for tile-key and placement-id in `koota.ts`. `findTileEntity` + `findPlacementEntity` are now O(1). `spawnGameboardPlan` fills both indexes; `spawnGameboardPlacement` registers; `removeGameboardPlacement` deregisters; `clearGameboardWorld` clears. 68/68 tests pass.
* [x] **CR-P1-5** — ✅ (2026-05-29) Added `KNOWN_EXTRA_ASSET_IDS` IIFE-computed `Set<string>` in `catalog.ts`. `isKnownExtraAssetId` is now a single `Set.has()` call. 68/68 tests pass.
* [x] **CR-P1-6** — ✅ PR #62 (2026-05-28): dedicated `coverage` job added to ci.yml running `pnpm test:coverage:enforce`; added as required status check in branch protection.
* [x] **CR-P1-7** — ✅ (2026-05-28) bootstrap-nightly.yml: SHA-pinned all 4 actions, added pull\_request paths trigger, hoisted HEX\_WORLDS\_OUT\_ROOT to job env.
* [x] **CR-P1-8** — ✅ (2026-05-28) engine.ts:663-665: null-check .at(-1) result, throw GameboardRuntimeError with actor.actorId + actor.spawnGroupId.
* [x] **CR-P1-9** — ✅ (2026-05-28) release.yml: guarded npm publish with `if: github.event_name == 'release'`.
* [x] **CR-P1-10** — ✅ (2026-05-28) core.ts: replaced `dirname(new URL(import.meta.url).pathname)` with `import.meta.dirname`.

### P2 — Medium (plan for next sprint)

[Section titled “P2 — Medium (plan for next sprint)”](#p2--medium-plan-for-next-sprint)

* [x] **CR-P2-1** — `_shared.ts` decomposition: per-command files; extract `emitOutput()` helper; fix `commandHandlerMutations` to throw `GameboardRuntimeError` on `never`. \[CQ-1, CQ-2]
* [x] **CR-P2-2** — ✅ PR #69 (2026-05-29): `findGameboardPath`/`reachableGameboardTiles` default-arg Map allocations routed through `gameboardPlanIndex` WeakMap.
* [x] **CR-P2-3** — ✅ PR #69 (2026-05-29): world.query() spreads removed (patrol.ts:227, movement.ts:421); flatMap+spread in runGameboardSystems replaced with nested for-loop push. Koota world.query() verified snapshot via .slice() — gemini live-iterator concern was a false positive.
* [x] **CR-P2-4** — ✅ `gameboard.ts` no longer statically imports `freeManifest`; `requiresExtraAsset` uses catalog treatment metadata, `getPlacementAsset` is explicit-manifest sync, and new `loadPlacementAsset` lazy-loads the packaged FREE manifest via dynamic import. Added focused gameboard tests, public API snapshot update, and a `dist/gameboard.js` static import-graph guard proving the FREE manifest record chunk is not statically reachable. Also refreshed packed-consumer smoke peer fixture (`koota`, `three@^0.184.0`) and flat `baseUrl` URL assertion. Verified with `pnpm verify`, `pnpm docs-site:build`, packed-consumer smoke, and `npm pack --dry-run`.
* [x] **CR-P2-5** — ✅ `useGameboardDerivedRevision`: split React selector invalidation into state/tile/placement/actor/movement/quest/patrol domains, coalesced trait events through one microtask revision bump, and added jsdom tests proving placement selectors ignore tile-only updates and coalesce repeated placement changes. `pnpm verify` green. \[P-10]
* [x] **CR-P2-6** — ✅ `stageUpstreamSource`: inlined github download path with `try/finally` for `downloadRoot` cleanup; `stageFromZip` restructured to `let succeeded = false; try { ... succeeded = true; } finally { if (!succeeded) rmSync(...) }`.
* [x] **CR-P2-7** — ✅ `readSidecar`: added `SIDECAR_MAX_BYTES = 4 MiB` + `SIDECAR_MAX_FILES = 100_000` constants; guards throw `GameboardIoError` on oversize or overcount.
* [x] **CR-P2-8** — ✅ `walkFilesInternal`: added `symlinkCount` ref parameter; warns once on stderr when symlink encountered; passes through recursive calls.
* [x] **CR-P2-9** — ✅ `koota.ts` no longer imports `isKnownExtraAssetId` from `scenario`; runtime placement spawn/update now require callers to set or preserve `requiresExtra` explicitly. Added Koota regression coverage for explicit EXTRA tagging. `pnpm verify` green. \[AR-1]
* [x] **CR-P2-10** — ✅ `ci.yml`: unified pnpm/action-setup and actions/setup-node SHAs across all 4 jobs to `v6.0.8` / `v6.4.0` (docs job was on v4.2.0/v6.3.0).
* [x] **CR-P2-11** — ✅ `release.yml`: added post-publish `npm audit signatures` verify step; wrote `ROLLBACK.md` runbook covering deprecate, unpublish, patch-release, and signature failure scenarios.
* [x] **CR-P2-12** — ✅ `automerge.yml`: branch protection now has strict required checks (`lint`, `typecheck`, `build`, `test`, `Docs Site Build`, `Semgrep SAST`, `Dependency Review`, `Coverage`), so Dependabot keeps `gh pr merge --auto --squash` behind the gate while release-please auto-approval/auto-merge is removed. Release PRs are now a maintainer checkpoint for the computed version + changelog; workflow contract + deployment docs updated. Local proof: `pnpm exec vitest run tests/contract/workflows-contract.test.ts --config vitest.config.ts`; `pnpm typecheck`; `pnpm lint`. \[CI-6]
* [x] **CR-P2-13** — ✅ H-DOC-1: fixed CLI reference redundant binary mention; H-DOC-2: added package rename narrative to CHANGELOG.md 1.0.0 + created `docs-site/guides/migration.md`; H-DOC-3: added JSON flag schema/error-contract subsection; M-DOC-1: added `HEX_WORLDS_OUT_ROOT` danger aside.
* [x] **CR-P2-14** — ✅ Removed `it.skip` at cli.test.ts:1922 (fixture key updated to `fixture-castle-kit` to satisfy `[A-Za-z0-9_:-]+` guard); tightened `__proto__` guard message assertion in cli-security.test.ts; fixed `--pieces` arg to use temp file (CLI requires path, not inline JSON). Skips at lines 219 (Phase RB) and 1426 (Phase RS) remain legitimately blocked.
* [x] **CR-P2-15** — ✅ `requirePlacementState` now returns `Readonly<PlacementStateValue>` (live ECS value, no copy) for internal reads; `snapshotPlacementState` does the deep-spread and is used only at the two external-result callsites (requestGameboardMovement and movementAdvanceResult).
* [x] **CR-P2-16** — ✅ `tsconfig.json`: removed `ignoreDeprecations: "6.0"`; migrated all `paths` values from bare relative (`src/...`) to `./`-prefixed relative (`./src/...`) and removed `baseUrl: "."` — TS 6 requires explicit relative paths in `paths` when `baseUrl` is absent. tsc clean, all 68 test files pass.
* [x] **CR-P2-17** — ✅ `tsup.config.ts`: added `treeshake: true` explicit; documented bundle model (honeycomb-grid/seedrandom/citty/yauzl bundled as deps; koota/react/three external as peerDeps); added `tests/unit/bundle-size.test.ts` with 60KB ceiling on index.js + 100KB ceiling on cli.js (skips when dist/ absent).
* [x] **CR-P2-18** — ✅ `release.yml`: pinned `npm@11.11.0` (was `@latest`); added `@cyclonedx/cyclonedx-npm@4.2.1` as pinned devDependency; switched from `npx --yes @cyclonedx/cyclonedx-npm@latest` to `pnpm exec cyclonedx-npm`; updated contract test assertion to match.

### P3 — Backlog

[Section titled “P3 — Backlog”](#p3--backlog)

* [x] **CR-P3-1** — ✅ Architecture decomposition: `simulation/script.ts` (3,163 lines → script-types/validators/index); `gameboard/gameboard.ts` (2,228 lines → plan/spawn-groups/terrain); `systems/systems.ts` (900 lines → command/tick/events); `scenario/catalog.ts` (2,401 lines). Progress: `simulation/script.ts` is now an 11-line stable public shim over `script-types.ts` (DTOs/schema/result records) and `script-validators.ts` (authored-script validators/scenario index); gameboard plan contracts, builder option contracts, memoized plan index, and plan summary helpers are split into `src/gameboard/plan.ts`; gameboard asset lookup/EXTRA/prop-cluster helpers are split into `src/gameboard/assets.ts`; derived terrain/connectivity placement construction is split into `src/gameboard/terrain.ts`, leaving `gameboard.ts` focused on builder/runtime construction behavior and built-in sample boards; board-aware spawn selection and spawn-group routing are split into `src/gameboard/spawn-groups.ts`; patrol waypoint and route-segment planning is split into `src/gameboard/patrol-routes.ts`, leaving `navigation.ts` focused on occupancy-backed pathfinding/reachability and public navigation re-exports; systems event contracts, event record contracts, and snapshot serializers are split into `src/systems/events.ts`; systems command dispatch contracts/helpers are split into `src/systems/command-dispatch.ts`; systems patrol/movement/quest tick orchestration is split into `src/systems/tick.ts`, leaving `systems.ts` focused on action bundles and command-plus-tick composition; scenario guide-page image/table normalization is split into `src/scenario/catalog-guide-data.ts`, and KayKit public treatment construction is split into `src/scenario/catalog-treatments.ts`, leaving `catalog.ts` focused on public constants, queries, inverse indexes, coverage summaries, and Markdown rendering without moving the public `/catalog` API surface. Local proof: `pnpm typecheck`; focused catalog/public API/docs contract Vitest slice. \[AR-4, AR-5, AR-6]
* [x] **CR-P3-2** — ✅ `noRestrictedImports` enforcement gaps: added `../interop/internal`, `../internal/predicates`, trait deep paths, config JSON deep paths, and `.js` mirrors for every extensionless restricted path; routed existing trait imports through `../traits`; added a contract test for required gaps and `.js` mirror coverage. Local proof: `pnpm exec vitest run tests/contract/biome-restricted-imports-contract.test.ts --config vitest.config.ts`; focused actor/Koota/movement/patrol/quest/public-api Vitest slice; `pnpm typecheck`; `pnpm lint`; `pnpm verify`. \[AR-10, BP-8]
* [x] **CR-P3-3** — ✅ `interop/coverage.ts` cohesion: documented the release-tooling vs runtime interop split in the architecture page, mirrored the distinction in the `coverage.ts` module comment, and clarified both public API guide copies so `./coverage` is build/review tooling rather than runtime ECS adapter glue. Kept the existing `src/interop/coverage.ts` location because `/coverage` is already a stable public surface joining interop, compatibility, manifest, scenario, and visual evidence. Local proof: `pnpm exec vitest run src/interop/__tests__/coverage.test.ts tests/contract/docs-frontmatter-contract.test.ts --config vitest.config.ts`; `pnpm lint`; `pnpm typecheck`; `pnpm docs-site:build`. \[AR-7]
* [x] **CR-P3-4** — ✅ Branded types: added public-api migration status tables to both docs-site canonical and legacy metadata guides, explicitly stating branded IDs are NOT yet enforced; added a docs contract pinning the caveat, tracked domains, tracked brands, and current implementation boundary. \[AR-8, M-DOC-4]
* [x] **CR-P3-5** — ✅ `useStableOptions` JSON.stringify: added a plain-empty-options fast-path before serialization; the React memoization test is now included in the main Vitest config and pins that fresh `{}` selector options do not call `JSON.stringify`. Local proof: `pnpm exec vitest run src/react/__tests__/memoization.test.tsx --config vitest.config.ts`. \[P-11]
* [x] **CR-P3-6** — ✅ Added `.github/workflows/benchmarks.yml` to run `pnpm build` + `pnpm bench` on main pushes, nightly schedule, manual dispatch, and benchmark-wiring PRs; uploads text benchmark output plus metadata artifacts; workflow contract now pins the benchmark workflow shape and SHA-pinned actions. \[T-bench]
* [x] **CR-P3-7** — ✅ Inline docs: added A\* heap/heuristic commentary in `findHexPath`; patrol state-machine transition diagram above `advancePatrolEntity`; section maps for the split simulation script implementation (`script-types.ts` and `script-validators.ts` behind the stable `script.ts` shim); and `docs/` vs `docs-site/` canonical ownership guidance in CONTRIBUTING.md. \[L-DOC-1, L-DOC-2, M-DOC-5, L-DOC-3]
* [x] **CR-P3-8** — ✅ `CI_GITHUB_TOKEN` PAT removed from release-please auth. `cd.yml` now mints a repo-scoped GitHub App installation token via pinned `actions/create-github-app-token@bcd2ba49218906704ab6c1aa796996da409d3eb1` (v3.2.0), requests only the current repository, narrows App-token permissions to contents/pull-requests write, keeps the job `GITHUB_TOKEN` read-only, and passes `steps.release-please-token.outputs.token` to release-please. Deployment docs name `vars.RELEASE_PLEASE_APP_CLIENT_ID` + `secrets.RELEASE_PLEASE_APP_PRIVATE_KEY`; workflow contract rejects `secrets.CI_GITHUB_TOKEN`. \[CI-9]
* [x] **CR-P3-9** — ✅ `GAMEBOARD_REQUIRED_BROWSER_SCREENSHOT_ARTIFACTS` now re-exports through `src/interop/coverage.ts` and the `src/interop/index.ts` barrel. The CLI coverage command imports it from `../../interop` instead of `../../interop/internal`, coverage tests pin the barrel path, and the public API snapshot records the intentional release-tooling export. \[L-1/Sec, AR-2]
* [x] **CR-P3-10** — ✅ `advancePatrolEntity` split into explicit transition helpers for inactive, invalid-route, existing-movement, idle/wait/completed, and request-next-segment branches. Trait writes stay in the same behavior points, but the monolithic early-return ladder and mutable `nextAgent` flow are replaced with `PatrolAdvanceTransition` objects. Patrol edge tests, simulation patrol tests, lint, typecheck, and full verify pass locally. \[CQ-7]
* [x] **CR-P3-11** — ✅ `hashFile` now hashes through `stream/promises.pipeline` into a hashing `Writable`, so verification waits for stream cleanup instead of resolving on the read stream `end` event. Bootstrap core tests, lint, typecheck, and full verify pass locally. \[CQ-9]
* [x] **CR-P3-12** — ✅ Removed the dead `src/simulation/simulation.ts` double-shim and moved the public simulation barrel directly into `src/simulation/index.ts`. Source docs now point at `src/simulation/index.ts`; focused simulation/public API tests, lint, typecheck, and full verify pass locally. \[AR-3]

# RFC-0001 render surface — build log (in progress)

> Progress record for RFC-0001 (generic asset sources + the declarative render surface). Migrated out of the live directive so the queue tracks only remaining work. Completed through the JSX element layer + docs-site workspace member; RFC-0001 is still open (one giant PR

> **Live milestone — build log, not an archive.** RFC-0001 is still in flight on `feat/generic-asset-sources` (PR #220, the one-giant-PR accumulator). This page holds the per-commit record for the COMPLETED portion (workspace, G0, RFC0-7, RFC0-8 + element layer, docs-site member) so `.agent-state/directive.md` carries only the remaining `[ ]` queue. Spec of record: `packages/declarative-hex-worlds/docs/rfcs/0001-generic-asset-sources.md`.

## Completed items (verified: local green + CI green)

[Section titled “Completed items (verified: local green + CI green)”](#completed-items-verified-local-green--ci-green)

* [x] RFC0-7 `AssetSource` interface; extract KayKit `gltf-pack` as the first impl behind it (pure refactor, existing GLTF tests are the net). ✅ commit b06c7bb: `src/asset-source/source.ts` (AssetSource iface + AssetRenderRequest union ‘gltf’|‘tileset-cell’ + ResolveContext + CellRect/HexDims, type-only → coverage-excluded), `gltf-pack.ts` (createGltfPackSource wraps resolveGameboardPlacementAssetUrl+transformForPlacement → {type:‘gltf’}, 100% covered, 7 tests). Design: docs/plans/declarative-render-surface.design.md. Umbrella + ./asset-source + public-api snapshot updated. Suite 2674 pass.

* [x] RFC0-8 `./tileset` + declarative render surface — DONE. Tileset manifest + UV-cell math + textured-hex mesh + bridge dispatch + the full JSX element surface, all CI-green. (SimpleRPG tileset render mode + zero-config wrapper are follow-ons under RFC0-2/showcase work.)

  * ✅ G2 manifest + cell selection DONE: commit 147cf8a (TilesetManifest Zod schema, 8 tests) + 08abd2d (createTilesetSource: biome/edge→tileset-cell, FNV-1a hash fill selection, cellRect helper, 15 tests). Both 100% covered, in `src/asset-source/`.
  * ✅ buildTexturedHexMesh DONE: commit 61487f3. `src/three/textured-hex.ts` — buildHexGeometry (center+6-corner fan BufferGeometry, pointy-top default, per-cell UVs, V-flipped) + buildTexturedHexMesh (MeshBasicMaterial, transparent, DoubleSide). Pure three, unit-covered, 10 tests, 100%. NOTE geometry math: pointy-top X-extent = halfW·cos30°, Z-extent = halfH (corner at 90°).
  * ✅ BRIDGE DISPATCH DONE: commit 61f6076. src/three/three.ts loadGameboardPlacementObject now dispatches on an optional `source?: AssetSource`: tileset-cell → loadTilesetCellObject (GameboardSheetTextureLoader injectable+LRU-cached via loadSheetTextureCached → buildTexturedHexMesh → transform → tag → LoadedGameboardPlacementObject{mesh, clips:\[]}); gltf/no-source → unchanged GLTF path. 5 unit tests + tests/browser/tileset-render.test.ts (3×3 board in real Chromium/WebGL, canvas-backed sheet, asserts 9 meshes + non-empty pixels — covers three.ts dispatch for the merged strict-100 gate; registered in vitest.browser.free.config.ts). No import cycle (type-only asset-source↔three).
  * ✅ JSX SURFACE (RFC0-8b) DONE: `src/react-elements/` + `./react-elements` subpath (subpath-only, NOT umbrella — keeps @react-three/fiber an optional peer for consumers who don’t want the elements). `<HexWorld>` (Canvas-free: koota providers + source registry), `<GameboardObjects>` (R3F bridge — useFrame → the extracted pure syncHexWorldPlacements), `<Tile>`/`<Model>`/`<Sprite>` (spawn/remove koota placements on mount/unmount), `<Tileset>` (registers a tileset source), + hooks useHexWorld/useTile/usePlacement/ useHexPath. combineSources (first-match composite) + syncHexWorldPlacements extracted as pure fns → unit-tested (src/react-elements/**tests**/objects.test.ts, 8 tests); the R3F component wrapper is /\* v8 ignore \*/ (untraceable through R3F’s reconciler, logic covered). Element logic browser-tested via plain createRoot (tests/browser/react-elements.test.ts, 13 tests — NOT inside , since only needs R3F; that’s a Canvas smoke). Needed vitest.browser config: React dedup + @react-three/fiber in optimizeDeps (R3F’s own reconciler was loading a 2nd React → useMemo null). All files 100% covered, full suite 2723 pass, build+DTS green. FOLLOW-ONS (not blocking RFC0-8): useSelection + useCamera hooks land with their backing features (a selection-state model + RFC0-CAM); zero-config wrapper; SimpleRPG tileset render mode (RFC0-2).

**Decision:** is Canvas-free — the consumer owns the R3F , dhw owns the board composition + render-sync bridge inside it. **Why:** Canvas/camera/renderer/lights/post are app+art decisions (burden side of the boon/burden line); owning them would presume and constrain. A Canvas-free primitive composes with consumer R3F content and stays testable. Optional covers zero-config. **Resolves:** RFC0-8b element-layer architecture (Canvas ownership). — resume state + gap finding —

### RFC-0001 resume state (2026-07-06, after G0)

[Section titled “RFC-0001 resume state (2026-07-06, after G0)”](#rfc-0001-resume-state-2026-07-06-after-g0)

**Branch:** feat/generic-asset-sources, PR #220 (draft). CI green on RFC0-1 + G0 (build/lint/typecheck/coverage/bootstrap/benchmarks pass; CodeQL is GitHub default-setup = neutral/flaky, NOT a real gate).

**DONE + verified (local green + CI green):**

* RFC0-1 workspace move (library → packages/declarative-hex-worlds, private root, only lib publishes, native pnpm caching CI, release-please retargeted).
* RFC0-G0 Zod AssetSourceSpec (src/asset-source/, ./asset-source subpath) + free.ts retirement (16.5k→41 lines) + pnpm catalog + zod dep. 2662 tests pass.
* docs-site adopted as `packages/docs-site` workspace member (commit c619ec0) — the STRUCTURAL PREREQUISITE for RFC0-4’s live SimpleRPG React island: only a member can `workspace:*`-depend on the library + `@declarative-hex-worlds/simple-rpg`. pnpm typedoc-plugin-markdown strict-isolation failure solved via root `.npmrc` (`hoist-pattern[]=*` to keep defaults + `*typedoc-plugin*` + `starlight-typedoc`). astro/tsconfig.typedoc entryPoints repointed to sibling lib; cli-reference + docs-frontmatter/branded-types contract tests repointed under packages/docs-site; ci/cd docs-site jobs collapsed to one workspace install. 2683 tests pass; docs build 1194 pages; frozen install clean. (RFC0-4 showcase-CAPTURE still open — waits on RFC0-8 declarative surface + RFC0-2 SimpleRPG render.)

**NEXT — RFC0-2 (SimpleRPG package), a large mechanical move:**

* packages/simple-rpg/ is SCAFFOLDED (package.json private workspace:\* dep, tsconfig with jsx). Empty src/ — needs the actual move.
* MOVE src/guides/simple-rpg/{smoke,exercises,types,index}.ts → packages/simple-rpg/src/ (these import the library by PACKAGE NAME already — clean).
* MOVE the scattered SimpleRPG tests into packages/simple-rpg/tests/: tests/integration/simple-rpg/*, tests/e2e/simple-rpg*, tests/browser/simple-rpg-visual.test.ts, tests/unit/simple-rpg.test.ts, tests/simple-rpg/\*. REPOINT their relative imports (../../src, ../../../src/guides/simple-rpg) to the package name ‘declarative-hex-worlds’ + local paths.
* The library’s src/guides/simple-rpg/**tests**/{smoke,exercises}.test.ts move too.
* Add packages/simple-rpg/vitest.config.ts; ensure `pnpm --filter @declarative-hex-worlds/simple-rpg test` green.
* Update the library’s tsconfig include/exclude + any contract test that counted simple-rpg files.
* CI: add a layered simple-rpg e2e job that runs AFTER the library suite (needs:), per D-test-topology.
* Give SimpleRPG an R3F render surface + run states (compose/cross-pack/pathfind/viewport) — this is where the real gap-finding + showcase capture begins (RFC0-4).

**THEN (Phase 2):** RFC0-7 AssetSource interface (build on G0) → RFC0-8 ./tileset + declarative /// elements + hooks → RFC0-CAM camera → RFC0-CLI binder + web configurator → RFC0-TEX/TAG/NORM/OVERLAY/ACC (CC0-pack gaps) → RFC0-10 three downloadable KayKit defaults → Phase 1 showcase backbone swap → RFC0-14 little-legends re-homing. See RFC 0001 for the full design.

### Gap-finding result (2026-07-06): NO declarative render surface exists yet

[Section titled “Gap-finding result (2026-07-06): NO declarative render surface exists yet”](#gap-finding-result-2026-07-06-no-declarative-render-surface-exists-yet)

SimpleRPG’s first render attempt confirms the RFC thesis gap: the library ships React PROVIDERS + HOOKS (GameboardRuntimeProvider, useGameboardState, useGameboardPlacementSnapshots, action hooks) but NO ready-to-use board React component — no ///. A consumer must hand-wire R3F

* syncGameboardPlacementObjects (the imperative three bridge) themselves — exactly what little-legends’ HexBoard did. So SimpleRPG can’t render declaratively until RFC0-8 (the /// + elements + hooks that proxy koota+honeycomb+three) exists. EFFECTIVE ORDER: build RFC0-8 declarative elements NEXT (the core deliverable per the React thesis), with SimpleRPG as their first consumer + gap-finder. The imperative bridge becomes the internal engine under the declarative surface.

## RFC0-CORE — the `./core` koota-free + three-free tier (complete)

[Section titled “RFC0-CORE — the ./core koota-free + three-free tier (complete)”](#rfc0-core--the-core-koota-free--three-free-tier-complete)

The “declare + JSON + validate + hex math + interop, bring-your-own runtime/renderer” tier. Three source splits + an isolated build + a source-and-built purity contract.

* **Recipe split** (commit 237874f): `recipe.ts`’s only koota use — `applyGameboardRecipeGeneration` (seeded layout-fill via a koota world) — moved to `src/scenario/recipe-generation.ts`. `createGameboardPlanFromRecipe` gained an injectable `applyGeneration` param defaulting to a module-level applier: `pureRecipeGenerationApplier` (koota-free; passes no-fill-rule generation through, throws a clear “requires the runtime tier” if fill rules present). The runtime tier wires the koota applier as the default on import (side-effect via the scenario barrel), so all \~10 callers keep today’s behavior. recipe.ts → zero koota.
* **Layout split** (commit 0ac4f4f): layout.ts’s 2 koota-spawning exports (`spawnGameboardLayoutPlacements`, `spawnGameboardLayoutFill`) + `projectWorldForLayout` moved to `src/coordinates/layout-runtime.ts`; the 10 pure layout fns stay. projection.ts needed NO split — all 3 exports take a World (runtime-only module `./core` omits).
* **`./core` barrel + subpath** (commit a87f180): `src/core/index.ts` re-exports the pure modules directly (bypassing the runtime-mixed barrels), `./core` subpath added.
* **Isolated build** (commit 205f7de): tsup.config is now an array — main build (splitting:true, for koota trait-identity stability) + a standalone `core` build (splitting:false), so `dist/core.js` never shares a koota-importing chunk. Verified: the built core imports only honeycomb-grid + seedrandom + zod; `import('./dist/core.js')` loads 112 exports in a koota-less context.
* **Contract**: `tests/contract/core-tier-purity-contract.test.ts` asserts BOTH the source import graph AND the built dist/core.js are koota/three/react-free (4 tests, regression-locked).

# State

> Current published version, in-flight initiatives, links to PRD + directive.

## Current state (pre-1.0)

[Section titled “Current state (pre-1.0)”](#current-state-pre-10)

The library is pre-1.0. The published npm version is below the major-version stability boundary; APIs can move.

The 1.0 stabilization PR (`codex/1.0-stabilization-phase-2`) closes the gap to 1.0 by working through 4 phases:

* **Phase R** — restructure (de-monorepo, decompose `src/` into 20 sub-packages, co-locate tests, drop bundled assets).
* **Phase A–E** — foundation gates (lint, typecheck, audit, coverage), perf criticals, security criticals, architectural debt, test debt to 100/100/100/100.
* **Phase F** — documentation (Astro Starlight site at [docs-site](/), SimpleRPG-driven feature gallery, marketing README, full audit).
* **Phase G** — release readiness (SLSA L3, SBOM, version bump, npm publish).

## In-flight initiatives

[Section titled “In-flight initiatives”](#in-flight-initiatives)

The authoritative work queue is [`.agent-state/directive.md`](https://github.com/jbcom/declarative-hex-worlds/blob/main/.agent-state/directive.md). Open items at a glance:

* **Asset bootstrap rollout** — `bootstrapKayKitAssets()` ships; bringing the FREE browser visuals CI job out of `RUN_BROWSER_VISUALS` gating once the bootstrap step is wired into CI.
* **SimpleRPG `game/` decomposition** — the test-driver implementation grows from a single 1,005-line file into per-domain sibling modules (scenarios, pieces, systems, render, cli) to expose every public API.
* **Feature gallery** — `docs-site/src/content/docs/features/` fills with screenshot-driven pages (harbors, bridges, multi-depth, prop injection, cross-kit composition, determinism) produced by SimpleRPG.
* **Marketing README rebuild** — replaces the current feature-enumeration with a 3-screenshot hero strip + 30-line quickstart + “why this exists” pitch.
* **Coverage ratchet to 100%** — the E0-E10 sub-epic closes the remaining \~35% gap between the current floor and the PRD §6 invariant of 100/100/100/100.

## Reference

[Section titled “Reference”](#reference)

|                       | Where                                                          |
| --------------------- | -------------------------------------------------------------- |
| PRD 1.0               | `docs/PRD/1.0.md` in the repo                                  |
| Work queue            | `.agent-state/directive.md`                                    |
| Test trinity overview | [`/guides/testing/`](/guides/testing/)                         |
| Release flow          | [`/about/deployment/`](/about/deployment/)                     |
| Architecture          | [`/about/architecture/`](/about/architecture/)                 |
| Design pitch          | [`/about/design/`](/about/design/)                             |
| API reference         | [`/reference/`](/reference/) (1107 pages generated from JSDoc) |

# Features

> Screenshot-driven feature gallery of declarative-hex-worlds.

import { Aside } from ‘@astrojs/starlight/components’;

The gallery shows every facet of the library a prospective consumer needs to understand. Each page is structured the same way: a problem statement, a minimal TypeScript snippet, the library API cross-links, related features.

Screenshot embedding lands once the F-Gallery test harness flips on with the RB browser-CI gate (PRD F-Gallery-1). The prose + snippets compile + run today.

## Gallery

[Section titled “Gallery”](#gallery)

| Feature                                                     | What it shows                                                       |
| ----------------------------------------------------------- | ------------------------------------------------------------------- |
| [Harbors](/features/harbors/)                               | Fixed gameboard composition with water + piers + village settlement |
| [Bridges and connectors](/features/bridges-and-connectors/) | Procedural seed-stable bridges across rivers                        |
| [Multi-depth stacks](/features/multi-depth-stacks/)         | Cliffs, plateaus, layered biomes via per-tile depth                 |
| [Tile injection](/features/tile-injection/)                 | Mutate tile state at runtime via commands                           |
| [Prop injection](/features/prop-injection/)                 | Add decorative or interactive props after build                     |
| [Pieces and actors](/features/pieces-and-actors/)           | Player + NPCs + props with team / hostility / interaction metadata  |
| [Movement and patrols](/features/movement-and-patrols/)     | Cost-aware pathing + scripted patrol routes                         |
| [Quests](/features/quests/)                                 | Multi-objective quests with progress + completion events            |
| [Cross-kit composition](/features/cross-kit-composition/)   | Mix KayKit Hexagon + Adventurers + Kenney assets                    |
| [Determinism replay](/features/determinism-replay/)         | Save seed + script → reproduce exact world + simulation anywhere    |

# Bridges and connectors

> Procedurally bridge rivers and ravines with seed-stable connector tiles.

import { Aside } from ‘@astrojs/starlight/components’;

Screenshot embedding lands once the F-Gallery test harness flips on with the RB browser-CI gate.

## Problem

[Section titled “Problem”](#problem)

A river splits your board into two halves and you want the procedural generator to lay down two or three bridges at sensible spans (not too close, not over impassable terrain) every time the same seed runs.

## Snippet

[Section titled “Snippet”](#snippet)

```ts
import { createSeededGameboardPlan } from 'declarative-hex-worlds/rules';


const plan = createSeededGameboardPlan({
  seed: 'forest-with-river-3',
  shape: { kind: 'rectangle', width: 12, height: 8 },
  generators: [
    { kind: 'river', source: { q: 0, r: 3 }, sink: { q: 11, r: 5 } },
    { kind: 'bridges', maxBridges: 3, minSpacing: 3 },
  ],
});


// Same seed → same river path → same bridges. Always.
```

## What the library handles

[Section titled “What the library handles”](#what-the-library-handles)

* **River pathing.** A\* between source + sink with terrain-cost weighting.
* **Bridge placement.** Seed-aware sampler picks span sites that satisfy `minSpacing` and don’t cross unrenderable terrain.
* **Determinism contract.** [See the determinism guide.](/guides/determinism/)

## API cross-links

[Section titled “API cross-links”](#api-cross-links)

* [`createSeededGameboardPlan`](/reference/rules/)
* [`GameboardLayoutArchetype`](/reference/layout/)

## Related features

[Section titled “Related features”](#related-features)

* [Harbors](/features/harbors/)
* [Multi-depth stacks](/features/multi-depth-stacks/)

# Cross-kit composition

> Mix KayKit Medieval Hexagon tiles with KayKit Adventurers characters and other GLTF packs.

import { Aside } from ‘@astrojs/starlight/components’;

Screenshot embedding lands once the F-Gallery test harness flips on with the RB browser-CI gate.

## Problem

[Section titled “Problem”](#problem)

You want KayKit Medieval Hexagon Pack tiles for the gameboard, but characters from KayKit Adventurers 2.0 (FREE) for the player + NPCs, plus a tower asset from Kenney’s Castle Kit as a special landmark.

## Snippet

[Section titled “Snippet”](#snippet)

```ts
import {
  analyzeExternalAssetCompatibility,
  declareGameboardPiecesFromCompatibilityReports,
  createGameboardPieceRegistry,
  createGameboardPieceSourceUrlMap,
} from 'declarative-hex-worlds';


const knightReport = await analyzeExternalAssetCompatibility({
  assetUrl: '/assets/adventurers/knight.gltf',
  intendedRole: 'unit',
});


const pieces = declareGameboardPiecesFromCompatibilityReports([
  { name: 'adventurer:knight', report: knightReport, role: 'unit' },
]);
const registry = createGameboardPieceRegistry(pieces);
const urlByAssetId = createGameboardPieceSourceUrlMap(registry, {
  sourceRoots: { 'adventurers': '/assets/adventurers' },
});
```

## What the library handles

[Section titled “What the library handles”](#what-the-library-handles)

* **GLTF inspection.** Reads bounds, rig presence, animation clips, material slots from any GLTF; reports placement compatibility.
* **Piece declaration.** Wraps the report into a `GameboardPieceDeclaration` that fits the manifest schema.
* **URL resolution.** Per-source-pack URL maps so the renderer knows where to load each cross-kit asset from.
* **Size normalization.** [`normalizeAssetToCell`](/reference/normalize/) fits a different maker’s asset — even a different hex orientation — into the target cell, and [`overlayTransform`](/reference/overlay/) places it. The examples package bakes a few CC0 **Kenney Hexagon Kit** pieces (flat-top hexes, a different aspect than KayKit’s pointy-top cell) and a node test proves they normalize + overlay through these same seams — cross-maker extension, not just cross-kit within KayKit.

## API cross-links

[Section titled “API cross-links”](#api-cross-links)

* [`analyzeExternalAssetCompatibility`](/reference/interop/)
* [`declareGameboardPiecesFromCompatibilityReports`](/reference/pieces/)
* [`createGameboardPieceSourceUrlMap`](/reference/pieces/)

## Related features

[Section titled “Related features”](#related-features)

* [Pieces and actors](/features/pieces-and-actors/)
* [Asset bootstrap](/guides/asset-bootstrap/)

# Determinism replay

> Save the seed + script, reproduce the exact same world + simulation across every machine.

import { Aside } from ‘@astrojs/starlight/components’;

Screenshot embedding lands once the F-Gallery test harness flips on with the RB browser-CI gate.

## Problem

[Section titled “Problem”](#problem)

Your game has a “share replay” button. The user records 5 minutes of gameplay; you want any other player on any machine to reproduce that 5 minutes exactly — same world layout, same NPC paths, same combat outcomes — by loading just the seed + the input script.

## Snippet

[Section titled “Snippet”](#snippet)

```ts
import { createGameboardRuntimeFromScenario } from 'declarative-hex-worlds/runtime';
import { runGameboardScenarioSimulationScript } from 'declarative-hex-worlds/simulation';


const runtime = createGameboardRuntimeFromScenario(scenario);
const result = runGameboardScenarioSimulationScript(scenario, replayScript, {
  rounds: 300,
});


// Same scenario + same script always produces the same `result.events`.
// `result.events` is byte-identical to what the recorder produced.
```

## What the library handles

[Section titled “What the library handles”](#what-the-library-handles)

* **Seed threading.** Every random decision routes through `seedrandom`; same seed → same outputs.
* **Script replay.** `runGameboardScenarioSimulationScript` executes recorded commands in order; the event records become a fingerprint.
* **Cross-process gate.** PRD E1’s `tests/unit/determinism.test.ts` spawns N subprocesses + asserts byte-identity. The gate runs in default `pnpm test` — regressions can’t sneak in.

## API cross-links

[Section titled “API cross-links”](#api-cross-links)

* [`createSeededGameboardPlan`](/reference/rules/)
* [`runGameboardScenarioSimulationScript`](/reference/simulation/)
* [Determinism contract guide](/guides/determinism/)

## Related features

[Section titled “Related features”](#related-features)

* [Quests](/features/quests/)
* [Movement and patrols](/features/movement-and-patrols/)

# Harbors

> Compose a fixed harbor with water tiles, piers, and a small village settlement.

import { Aside } from ‘@astrojs/starlight/components’;

Screenshot embedding lands once the F-Gallery test harness flips on with the RB browser-CI gate. The snippet below compiles + runs today.

## Problem

[Section titled “Problem”](#problem)

You want a hex board where a stretch of coastline opens into a deep-water harbor with two wooden piers and a few boats at anchor. The terrain should validate (no land tiles inside the water cluster, piers spanning the shore, navigable tiles for actors).

## Snippet

[Section titled “Snippet”](#snippet)

```tsx
import { createGameboardBuilder } from 'declarative-hex-worlds/gameboard';


const plan = createGameboardBuilder({
  seed: 'harbor-village-7',
  shape: { kind: 'rectangle', width: 8, height: 6 },
})
  .addHarbor({ center: { q: 4, r: 2 }, radius: 2 })
  .addBridge({ from: { q: 3, r: 1 }, to: { q: 4, r: 1 } })
  .addBuilding({ at: { q: 1, r: 4 }, kind: 'tavern' })
  .addBuilding({ at: { q: 2, r: 4 }, kind: 'home_A' })
  .build();


// plan.tiles + plan.placements are deterministic — same seed, same harbor.
```

## What the library handles

[Section titled “What the library handles”](#what-the-library-handles)

* **Tile selection.** `addHarbor` picks water + coast variants from the FREE manifest, rotates them to match neighbouring tile edges.
* **Connectivity validation.** The bridge between `{q:3,r:1}` and `{q:4,r:1}` is rejected if those tiles aren’t adjacent.
* **Determinism.** Same seed → same harbor layout across every machine.
* **Placement metadata.** Every placement has a `metadata.layoutFootprintSize` + `metadata.pieceRole` for downstream rendering.

## API cross-links

[Section titled “API cross-links”](#api-cross-links)

* [`createGameboardBuilder`](/reference/gameboard/) — the entry point.
* [`GameboardBuilder.addHarbor`](/reference/gameboard/) — harbor placement.
* [`GameboardBuilder.addBridge`](/reference/gameboard/) — connector placement.
* [`projectWorldToGameboardPlan`](/reference/coordinates/) — once you’ve spawned the plan into a koota world, project back to a `GameboardPlan` for serialization.

## Related features

[Section titled “Related features”](#related-features)

* [Bridges and connectors](/features/bridges-and-connectors/)
* [Multi-depth stacks](/features/multi-depth-stacks/)
* [Cross-kit composition](/features/cross-kit-composition/)

# Movement and patrols

> Tile-to-tile movement with cost-aware pathing + scripted patrol routes for NPCs.

import { Aside } from ‘@astrojs/starlight/components’;

Screenshot embedding lands once the F-Gallery test harness flips on with the RB browser-CI gate.

## Problem

[Section titled “Problem”](#problem)

A guard NPC patrols a fixed route around the village walls. You want the patrol to step one tile per simulation tick, pause for 3 ticks at each waypoint, and reverse at the end of the loop.

## Snippet

[Section titled “Snippet”](#snippet)

```ts
import { GameboardPatrolAgent } from 'declarative-hex-worlds/patrol';


world.add(guardEntity, GameboardPatrolAgent({
  routeId: 'wall-loop',
  waypoints: ['2,2', '2,4', '4,4', '4,2'],
  pauseTicksPerWaypoint: 3,
  direction: 'forward',
  onLoopEnd: 'reverse',
}));
```

## What the library handles

[Section titled “What the library handles”](#what-the-library-handles)

* **Per-tick stepping.** `runGameboardSystems` advances every patrol agent one tile (or pauses) per tick.
* **Blocked-route fallbacks.** If the next waypoint becomes blocked, the agent waits + emits a `GameboardPatrolBlockedEvent`.
* **Event records.** Every step / wait / blocked event is captured in the simulation report for testing + replay.

## API cross-links

[Section titled “API cross-links”](#api-cross-links)

* [`GameboardPatrolAgent`](/reference/traits/)
* [`runGameboardSystems`](/reference/systems/)

## Related features

[Section titled “Related features”](#related-features)

* [Pieces and actors](/features/pieces-and-actors/)
* [Quests](/features/quests/)

# Multi-depth stacks

> Stack hex tiles at varying Y depths to build cliffs, plateaus, and layered biomes.

import { Aside } from ‘@astrojs/starlight/components’;

Screenshot embedding lands once the F-Gallery test harness flips on with the RB browser-CI gate.

## Problem

[Section titled “Problem”](#problem)

You want a cliff face: lower coastal hexes at depth 0, a sheer cliff at depth 1, and a plateau of grass + trees at depth 2. Visitors should be able to spawn on each tier; AI pathing should respect the elevation deltas.

## Snippet

[Section titled “Snippet”](#snippet)

```ts
import { createGameboardBuilder } from 'declarative-hex-worlds/gameboard';


const plan = createGameboardBuilder({
  seed: 'cliff-3',
  shape: { kind: 'rectangle', width: 6, height: 6 },
})
  .addTier({ at: { q: 1, r: 1 }, depth: 0, terrain: 'coast' })
  .addTier({ at: { q: 2, r: 1 }, depth: 1, terrain: 'cliff' })
  .addTier({ at: { q: 3, r: 1 }, depth: 2, terrain: 'grass' })
  .addNaturePlacement({ at: { q: 3, r: 1 }, kind: 'tree_single_A' })
  .build();
```

## What the library handles

[Section titled “What the library handles”](#what-the-library-handles)

* **HexTileState.depth.** Per-tile Y offset; the projection pipeline reads it for world-space height.
* **Stack rules.** Adjacent tile depth deltas above the configured threshold fail validation.
* **Navigation.** `createGameboardActorNavigationProfile` respects elevation cost when planning paths.

## API cross-links

[Section titled “API cross-links”](#api-cross-links)

* [`HexTileState`](/reference/traits/)
* [`projectWorldToGameboardPlan`](/reference/coordinates/)
* [`createGameboardActorNavigationProfile`](/reference/actors/)

## Related features

[Section titled “Related features”](#related-features)

* [Harbors](/features/harbors/)
* [Bridges and connectors](/features/bridges-and-connectors/)

# Pieces and actors

> Spawn the player, NPCs, and neutral actors with team/hostility/interaction metadata.

import { Aside } from ‘@astrojs/starlight/components’;

Screenshot embedding lands once the F-Gallery test harness flips on with the RB browser-CI gate.

## Problem

[Section titled “Problem”](#problem)

You need a player character on the harbor tile, a tavern keeper inside the tavern, and three hostile bandits camped on the road. Each has a different role flag + collision profile + interaction behavior.

## Snippet

[Section titled “Snippet”](#snippet)

```ts
import { registerGameboardActor, spawnGameboardActor } from 'declarative-hex-worlds/actors';


const player = registerGameboardActor(world, {
  id: 'player:you',
  kind: 'player',
  tileKey: '4,2',
  team: 'players',
});


const tavernKeeper = registerGameboardActor(world, {
  id: 'npc:keeper',
  kind: 'npc',
  tileKey: '1,4',
  team: 'neutrals',
});


const bandit = registerGameboardActor(world, {
  id: 'enemy:bandit-1',
  kind: 'npc',
  tileKey: '5,3',
  team: 'bandits',
  hostility: { towards: ['players', 'neutrals'] },
});
```

## What the library handles

[Section titled “What the library handles”](#what-the-library-handles)

* **Trait composition.** Each actor gets `GameboardActor` + (`IsPlayerActor` | `IsNpcActor` | `IsPropActor`) + (`IsHostileActor` if applicable) traits.
* **Team-based queries.** `HostileActorQuery` returns just the bandits relative to the player.
* **Tile occupancy.** Spawn refuses to place an actor on a tile that has a blocking placement.

## API cross-links

[Section titled “API cross-links”](#api-cross-links)

* [`registerGameboardActor`](/reference/actors/)
* [`GameboardActor`](/reference/traits/)
* [`HostileActorQuery`](/reference/actors/)

## Related features

[Section titled “Related features”](#related-features)

* [Movement and patrols](/features/movement-and-patrols/)
* [Quests](/features/quests/)

# Prop injection

> Attach decorative or interactive props to existing tiles after the board has rendered.

import { Aside } from ‘@astrojs/starlight/components’;

Screenshot embedding lands once the F-Gallery test harness flips on with the RB browser-CI gate.

## Problem

[Section titled “Problem”](#problem)

A merchant arrives at the tavern tile with three crates of trade goods. You want the crates rendered on the tile, queryable by AI, and removable when the merchant leaves.

## Snippet

[Section titled “Snippet”](#snippet)

```ts
import { spawnGameboardPlacement } from 'declarative-hex-worlds/koota';


const crateA = spawnGameboardPlacement(world, {
  tileKey: '2,4',
  assetId: 'crate_A_big',
  kind: 'prop',
  layer: 'prop',
  metadata: { ownerActorId: 'merchant:trader-7' },
});
```

## What the library handles

[Section titled “What the library handles”](#what-the-library-handles)

* **Placement spawn.** Adds the koota entity with `IsGameboardPlacement` + `PlacementOnTile` + `PlacementState` traits.
* **Footprint check.** Asserts the prop fits within the tile’s available footprint slots.
* **Query surface.** Consumer can later `findGameboardActor(world, ...)` to locate the merchant + iterate their placements.

## API cross-links

[Section titled “API cross-links”](#api-cross-links)

* [`spawnGameboardPlacement`](/reference/koota/)
* [`PlacementState`](/reference/traits/)

## Related features

[Section titled “Related features”](#related-features)

* [Tile injection](/features/tile-injection/)
* [Pieces and actors](/features/pieces-and-actors/)

# Quests

> Multi-objective quests with progress tracking, completion events, and replay-safe state.

import { Aside } from ‘@astrojs/starlight/components’;

Screenshot embedding lands once the F-Gallery test harness flips on with the RB browser-CI gate.

## Problem

[Section titled “Problem”](#problem)

A “Clear the harbor” quest has three objectives: defeat 5 bandits, deliver 3 crates to the tavern, talk to the harbormaster. The quest tracks each objective independently + fires a completion event when all three resolve.

## Snippet

[Section titled “Snippet”](#snippet)

```ts
import { GameboardQuest } from 'declarative-hex-worlds/quests';


world.spawn(GameboardQuest({
  id: 'quest:clear-harbor',
  title: 'Clear the harbor',
  objectives: [
    { id: 'defeat-bandits', kind: 'defeat-count', target: 5, current: 0 },
    { id: 'deliver-crates', kind: 'deliver-count', target: 3, current: 0 },
    { id: 'talk-harbormaster', kind: 'interact-actor', target: 'npc:harbormaster' },
  ],
  rewards: { gold: 100, xp: 250 },
}));
```

## What the library handles

[Section titled “What the library handles”](#what-the-library-handles)

* **Objective tracking.** Each kind has its own update hook that runs during the simulation tick.
* **Completion semantics.** A quest completes when every objective’s `status === 'satisfied'`.
* **Event records.** `GameboardQuestAdvancedEvent` / `GameboardQuestCompletedEvent` / `GameboardQuestBlockedEvent` for downstream UIs.

## API cross-links

[Section titled “API cross-links”](#api-cross-links)

* [`GameboardQuest`](/reference/traits/)
* [`GameboardQuestObjectiveProgress`](/reference/quests/)

## Related features

[Section titled “Related features”](#related-features)

* [Pieces and actors](/features/pieces-and-actors/)
* [Movement and patrols](/features/movement-and-patrols/)

# Tile injection

> Mutate tile state after the board is built — terrain swaps, depth lifts, connectivity rewires.

import { Aside } from ‘@astrojs/starlight/components’;

Screenshot embedding lands once the F-Gallery test harness flips on with the RB browser-CI gate.

## Problem

[Section titled “Problem”](#problem)

A river runs through your board. At runtime a quest objective dams the river upstream; downstream tiles need to switch from `water` to `mud` for the next 50 simulation ticks, then revert.

## Snippet

[Section titled “Snippet”](#snippet)

```ts
import { gameboardCommandActions } from 'declarative-hex-worlds/commands';
import { HexTileState } from 'declarative-hex-worlds/traits';


const swap = world.actions(gameboardCommandActions).plan({
  kind: 'inject-tile',
  tileKey: '4,2',
  patch: { terrain: 'mud' },
});
world.actions(gameboardCommandActions).execute(swap);


// Later, revert.
world.actions(gameboardCommandActions).execute({
  ...swap,
  patch: { terrain: 'water' },
});
```

## What the library handles

[Section titled “What the library handles”](#what-the-library-handles)

* **Trait mutation under koota’s transaction model.** Tile state changes are observable by queries.
* **Re-validation.** Connectivity rules re-run; downstream placements that depended on `water` neighbors may flag warnings.
* **Snapshot stability.** Post-mutation `runtime.snapshot()` reflects the new state; deterministic replay from the same script reproduces the same sequence.

## API cross-links

[Section titled “API cross-links”](#api-cross-links)

* [`gameboardCommandActions`](/reference/commands/)
* [`HexTileState`](/reference/traits/)

## Related features

[Section titled “Related features”](#related-features)

* [Prop injection](/features/prop-injection/)
* [Pieces and actors](/features/pieces-and-actors/)

# SUBCOMMAND_LOADERS

> `const` **SUBCOMMAND\_LOADERS**: `Record`<`string`, () => `Promise`<`CommandModule`>>

Defined in: [packages/declarative-hex-worlds/src/cli/cli.ts:39](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/cli.ts#L39)

Exported (not just module-local) so tests can assert every dispatchable command name has matching `--help` metadata in `./usage` (completeness test) without duplicating this map.

# assertPackPresent

> **assertPackPresent**(`id`, `rawAssetsRoot`): `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:132](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L132)

Assert a pack is materialized at `<rawAssetsRoot>/<packId>`, or throw a clear error naming the pack + the exact command to fetch it. This is the “absent → clear error” half of default source resolution (RFC0-10).

## Parameters

[Section titled “Parameters”](#parameters)

### id

[Section titled “id”](#id)

`string`

### rawAssetsRoot

[Section titled “rawAssetsRoot”](#rawassetsroot)

`string`

## Returns

[Section titled “Returns”](#returns)

`string`

# bootstrapKayKitAssets

> **bootstrapKayKitAssets**(`options`): `Promise`<[`BootstrapResult`](/declarative-hex-worlds/reference/cli/commands/bootstrap/interfaces/bootstrapresult/)>

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:218](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L218)

Materialize the KayKit asset tree under the consumer’s asset root.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`BootstrapKayKitAssetsOptions`](/declarative-hex-worlds/reference/cli/commands/bootstrap/interfaces/bootstrapkaykitassetsoptions/)

## Returns

[Section titled “Returns”](#returns)

`Promise`<[`BootstrapResult`](/declarative-hex-worlds/reference/cli/commands/bootstrap/interfaces/bootstrapresult/)>

# bootstrapPack

> **bootstrapPack**(`id`, `options`): `Promise`<[`BootstrapResult`](/declarative-hex-worlds/reference/cli/commands/bootstrap/interfaces/bootstrapresult/)>

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:76](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L76)

Fetch a registered pack by id from its upstream GitHub archive into `<rawAssetsRoot>/<packId>/`. Throws a clear error for an unknown pack id (via [packDescriptor](/declarative-hex-worlds/reference/cli/commands/bootstrap/functions/packdescriptor/)). The per-pack subdir is computed here (not caller-chosen) so the fetched pack is always locatable by the default-source resolvers.

## Parameters

[Section titled “Parameters”](#parameters)

### id

[Section titled “id”](#id)

`string`

### options

[Section titled “options”](#options)

[`BootstrapPackOptions`](/declarative-hex-worlds/reference/cli/commands/bootstrap/interfaces/bootstrappackoptions/)

## Returns

[Section titled “Returns”](#returns)

`Promise`<[`BootstrapResult`](/declarative-hex-worlds/reference/cli/commands/bootstrap/interfaces/bootstrapresult/)>

# detectDefaultBootstrapOut

> **detectDefaultBootstrapOut**(): `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/index.ts:141](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/index.ts#L141)

Default `--out` heuristic. Prefers existing `models` (flat bootstrap default), then `public/models` (Vite / Next.js public dir convention), then falls back to `models`. Cosmetic only: every call still routes through safeResolveOutput.

## Returns

[Section titled “Returns”](#returns)

`string`

# formatBytes

> **formatBytes**(`value`): `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/index.ts:170](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/index.ts#L170)

## Parameters

[Section titled “Parameters”](#parameters)

### value

[Section titled “value”](#value)

`number`

## Returns

[Section titled “Returns”](#returns)

`string`

# isPackId

> **isPackId**(`value`): value is “medieval-hexagon” | “adventurers” | “skeletons”

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts:132](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts#L132)

True if `value` names a registered pack (proto-safe — used on external input).

## Parameters

[Section titled “Parameters”](#parameters)

### value

[Section titled “value”](#value)

`string`

## Returns

[Section titled “Returns”](#returns)

value is “medieval-hexagon” | “adventurers” | “skeletons”

# isPackMaterialized

> **isPackMaterialized**(`id`, `rawAssetsRoot`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:99](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L99)

Whether a pack is materialized at `<rawAssetsRoot>/<packId>` (sidecar present). Validates the id at runtime (not just by the `PackId` type) so an external caller passing an unknown/hostile id gets a clear error, never a stray path.

## Parameters

[Section titled “Parameters”](#parameters)

### id

[Section titled “id”](#id)

`string`

### rawAssetsRoot

[Section titled “rawAssetsRoot”](#rawassetsroot)

`string`

## Returns

[Section titled “Returns”](#returns)

`boolean`

# kayKitFreeGithubTarballUrl

> **kayKitFreeGithubTarballUrl**(`commit?`): `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:349](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L349)

Format the canonical GitHub source-archive **zip** URL for a given ref (or `main` when unset). GitHub serves a stable, never-changing archive at `/archive/refs/heads/<ref>.zip`, so bootstrap downloads it and feeds the exact same local-zip extraction flow as a user-supplied archive — no tarball decompression and no git dependency.

## Parameters

[Section titled “Parameters”](#parameters)

### commit?

[Section titled “commit?”](#commit)

`string`

## Returns

[Section titled “Returns”](#returns)

`string`

# layoutForPack

> **layoutForPack**(`descriptor`): [`KayKitUpstreamLayout`](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/)

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:32](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L32)

Resolve the upstream layout for a pack descriptor. `terrain` packs use the medieval-hexagon layout (FREE edition); `playable`/`enemy` character packs use the flat character-pack layout keyed by the descriptor’s `addons/` folder.

## Parameters

[Section titled “Parameters”](#parameters)

### descriptor

[Section titled “descriptor”](#descriptor)

#### attribution

[Section titled “attribution”](#attribution)

`string` = `...`

Attribution string (CC0 — no attribution required, but credited by courtesy).

#### category

[Section titled “category”](#category)

`"terrain"` | `"enemy"` | `"playable"` = `...`

Gameplay category the pack fills.

#### displayName

[Section titled “displayName”](#displayname)

`string` = `...`

Human-facing name for CLI listings + docs.

#### github

[Section titled “github”](#github)

{ `archiveUrlTemplate`: `string`; `defaultRef`: `string`; `owner`: `string`; `repo`: `string`; } = `packGithubSourceSchema`

Upstream GitHub source.

#### github.archiveUrlTemplate

[Section titled “github.archiveUrlTemplate”](#githubarchiveurltemplate)

`string` = `...`

Archive-URL template with `{owner}`/`{repo}`/`{ref}` placeholders. Kept per descriptor (not global) so a pack hosted differently can override it.

#### github.defaultRef

[Section titled “github.defaultRef”](#githubdefaultref)

`string` = `...`

Default git ref fetched when none is supplied.

#### github.owner

[Section titled “github.owner”](#githubowner)

`string` = `...`

GitHub owner/org.

#### github.repo

[Section titled “github.repo”](#githubrepo)

`string` = `...`

Repository name.

#### id

[Section titled “id”](#id)

`"medieval-hexagon"` | `"adventurers"` | `"skeletons"` = `...`

Stable pack id.

#### packFolder

[Section titled “packFolder”](#packfolder)

`string` = `...`

Upstream `addons/<packFolder>/` directory name the pack publishes under.

#### role

[Section titled “role”](#role)

`"tile"` | `"model"` = `...`

Asset role the pack contributes.

## Returns

[Section titled “Returns”](#returns)

[`KayKitUpstreamLayout`](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/)

# listPackDescriptors

> **listPackDescriptors**(): readonly `object`\[]

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts:149](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts#L149)

Every pack descriptor, in registry order.

## Returns

[Section titled “Returns”](#returns)

readonly `object`\[]

# packArchiveUrl

> **packArchiveUrl**(`descriptor`, `ref?`): `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts:154](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts#L154)

Format a pack’s upstream archive URL for a given ref (or its default ref).

## Parameters

[Section titled “Parameters”](#parameters)

### descriptor

[Section titled “descriptor”](#descriptor)

#### attribution

[Section titled “attribution”](#attribution)

`string` = `...`

Attribution string (CC0 — no attribution required, but credited by courtesy).

#### category

[Section titled “category”](#category)

`"terrain"` | `"enemy"` | `"playable"` = `...`

Gameplay category the pack fills.

#### displayName

[Section titled “displayName”](#displayname)

`string` = `...`

Human-facing name for CLI listings + docs.

#### github

[Section titled “github”](#github)

{ `archiveUrlTemplate`: `string`; `defaultRef`: `string`; `owner`: `string`; `repo`: `string`; } = `packGithubSourceSchema`

Upstream GitHub source.

#### github.archiveUrlTemplate

[Section titled “github.archiveUrlTemplate”](#githubarchiveurltemplate)

`string` = `...`

Archive-URL template with `{owner}`/`{repo}`/`{ref}` placeholders. Kept per descriptor (not global) so a pack hosted differently can override it.

#### github.defaultRef

[Section titled “github.defaultRef”](#githubdefaultref)

`string` = `...`

Default git ref fetched when none is supplied.

#### github.owner

[Section titled “github.owner”](#githubowner)

`string` = `...`

GitHub owner/org.

#### github.repo

[Section titled “github.repo”](#githubrepo)

`string` = `...`

Repository name.

#### id

[Section titled “id”](#id)

`"medieval-hexagon"` | `"adventurers"` | `"skeletons"` = `...`

Stable pack id.

#### packFolder

[Section titled “packFolder”](#packfolder)

`string` = `...`

Upstream `addons/<packFolder>/` directory name the pack publishes under.

#### role

[Section titled “role”](#role)

`"tile"` | `"model"` = `...`

Asset role the pack contributes.

### ref?

[Section titled “ref?”](#ref)

`string`

## Returns

[Section titled “Returns”](#returns)

`string`

# packDescriptor

> **packDescriptor**(`id`): `object`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts:141](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts#L141)

Look up a pack descriptor by id, or throw a clear error listing the valid ids. Uses `Object.hasOwn` so an id equal to an `Object.prototype` member can’t return an inherited value.

## Parameters

[Section titled “Parameters”](#parameters)

### id

[Section titled “id”](#id)

`string`

## Returns

[Section titled “Returns”](#returns)

### attribution

[Section titled “attribution”](#attribution)

> **attribution**: `string`

Attribution string (CC0 — no attribution required, but credited by courtesy).

### category

[Section titled “category”](#category)

> **category**: `"terrain"` | `"enemy"` | `"playable"`

Gameplay category the pack fills.

### displayName

[Section titled “displayName”](#displayname)

> **displayName**: `string`

Human-facing name for CLI listings + docs.

### github

[Section titled “github”](#github)

> **github**: `object` = `packGithubSourceSchema`

Upstream GitHub source.

#### github.archiveUrlTemplate

[Section titled “github.archiveUrlTemplate”](#githubarchiveurltemplate)

> **archiveUrlTemplate**: `string`

Archive-URL template with `{owner}`/`{repo}`/`{ref}` placeholders. Kept per descriptor (not global) so a pack hosted differently can override it.

#### github.defaultRef

[Section titled “github.defaultRef”](#githubdefaultref)

> **defaultRef**: `string`

Default git ref fetched when none is supplied.

#### github.owner

[Section titled “github.owner”](#githubowner)

> **owner**: `string`

GitHub owner/org.

#### github.repo

[Section titled “github.repo”](#githubrepo)

> **repo**: `string`

Repository name.

### id

[Section titled “id”](#id-1)

> **id**: `"medieval-hexagon"` | `"adventurers"` | `"skeletons"`

Stable pack id.

### packFolder

[Section titled “packFolder”](#packfolder)

> **packFolder**: `string`

Upstream `addons/<packFolder>/` directory name the pack publishes under.

### role

[Section titled “role”](#role)

> **role**: `"tile"` | `"model"`

Asset role the pack contributes.

# packDir

> **packDir**(`rawAssetsRoot`, `id`): `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:46](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L46)

The single source of truth for where a pack lives under a raw-assets root: `<rawAssetsRoot>/<packId>/`. `bootstrapPack` WRITES here and the default-source resolvers READ here, so a pack fetched by the CLI is always found by `resolveDefaultPackKit`/`assertPackPresent` — the convention can’t diverge. Uses the validated `descriptor.id` (never a raw caller string) in the join.

## Parameters

[Section titled “Parameters”](#parameters)

### rawAssetsRoot

[Section titled “rawAssetsRoot”](#rawassetsroot)

`string`

### id

[Section titled “id”](#id)

`string`

## Returns

[Section titled “Returns”](#returns)

`string`

# printBootstrapResult

> **printBootstrapResult**(`result`): `void`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/index.ts:152](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/index.ts#L152)

## Parameters

[Section titled “Parameters”](#parameters)

### result

[Section titled “result”](#result)

[`BootstrapResult`](/declarative-hex-worlds/reference/cli/commands/bootstrap/interfaces/bootstrapresult/)

## Returns

[Section titled “Returns”](#returns)

`void`

# printBootstrapVerifyReport

> **printBootstrapVerifyReport**(`report`): `void`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/index.ts:159](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/index.ts#L159)

## Parameters

[Section titled “Parameters”](#parameters)

### report

[Section titled “report”](#report)

[`BootstrapVerificationReport`](/declarative-hex-worlds/reference/cli/commands/bootstrap/interfaces/bootstrapverificationreport/)

## Returns

[Section titled “Returns”](#returns)

`void`

# registeredPackClassifiers

> **registeredPackClassifiers**(): readonly [`PlacementClassifier`](/declarative-hex-worlds/reference/index/type-aliases/placementclassifier/)\[]

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:157](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L157)

The recognized-pack [PlacementClassifier](/declarative-hex-worlds/reference/index/type-aliases/placementclassifier/)s (RFC0-TAGb): one per registered pack, mapping each pack’s registry category to its default gameplay classifiers (Adventurers → playable, Skeletons → enemy/random-encounter; terrain packs contribute none). Compose these ON TOP of `DEFAULT_PLACEMENT_CLASSIFIERS` so a placement sourced from a recognized pack is auto-classified:

```ts
const classifiers = [...DEFAULT_PLACEMENT_CLASSIFIERS, ...registeredPackClassifiers()];
classifyPlacement(placement, classifiers);
```

## Returns

[Section titled “Returns”](#returns)

readonly [`PlacementClassifier`](/declarative-hex-worlds/reference/index/type-aliases/placementclassifier/)\[]

# resolveBootstrapGltfRoot

> **resolveBootstrapGltfRoot**(`assetRoot`): `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/target.ts:30](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/target.ts#L30)

Resolve the absolute path to a bootstrap target’s GLTF tree root. With the flat layout (gltfRelative = “”), this is the asset root itself.

## Parameters

[Section titled “Parameters”](#parameters)

### assetRoot

[Section titled “assetRoot”](#assetroot)

`string`

## Returns

[Section titled “Returns”](#returns)

`string`

# resolveBootstrapSidecarPath

> **resolveBootstrapSidecarPath**(`assetRoot`): `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/target.ts:40](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/target.ts#L40)

Resolve the absolute path to a bootstrap target’s integrity sidecar.

## Parameters

[Section titled “Parameters”](#parameters)

### assetRoot

[Section titled “assetRoot”](#assetroot)

`string`

## Returns

[Section titled “Returns”](#returns)

`string`

# resolveDefaultPackKit

> **resolveDefaultPackKit**(`rawAssetsRoot`): readonly [`PackResolution`](/declarative-hex-worlds/reference/cli/commands/bootstrap/interfaces/packresolution/)\[]

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:119](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L119)

Resolve every registered pack against a raw-assets root, reporting which are present and which are missing. An app composes its default game from the present packs; [assertPackPresent](/declarative-hex-worlds/reference/cli/commands/bootstrap/functions/assertpackpresent/) turns a missing required pack into a clear, actionable error. Convention: each pack lives at `<root>/<packId>/`.

## Parameters

[Section titled “Parameters”](#parameters)

### rawAssetsRoot

[Section titled “rawAssetsRoot”](#rawassetsroot)

`string`

## Returns

[Section titled “Returns”](#returns)

readonly [`PackResolution`](/declarative-hex-worlds/reference/cli/commands/bootstrap/interfaces/packresolution/)\[]

# runBootstrap

> **runBootstrap**(`parsed`, `edition`): `Promise`<`void`>

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/index.ts:61](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/index.ts#L61)

## Parameters

[Section titled “Parameters”](#parameters)

### parsed

[Section titled “parsed”](#parsed)

`ParsedArgs`

### edition

[Section titled “edition”](#edition)

`"free"` | `"extra"`

## Returns

[Section titled “Returns”](#returns)

`Promise`<`void`>

# verifyBootstrap

> **verifyBootstrap**(`outRoot`): `Promise`<[`BootstrapVerificationReport`](/declarative-hex-worlds/reference/cli/commands/bootstrap/interfaces/bootstrapverificationreport/)>

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:299](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L299)

Re-hash every file recorded in an integrity sidecar and report drift.

## Parameters

[Section titled “Parameters”](#parameters)

### outRoot

[Section titled “outRoot”](#outroot)

`string`

## Returns

[Section titled “Returns”](#returns)

`Promise`<[`BootstrapVerificationReport`](/declarative-hex-worlds/reference/cli/commands/bootstrap/interfaces/bootstrapverificationreport/)>

# BootstrapFileEntry

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:154](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L154)

Per-file entry in the integrity sidecar.

## Properties

[Section titled “Properties”](#properties)

### bytes

[Section titled “bytes”](#bytes)

> `readonly` **bytes**: `number`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:160](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L160)

Byte length of the file at fetch time.

***

### path

[Section titled “path”](#path)

> `readonly` **path**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:156](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L156)

POSIX path relative to `<out>/addons/kaykit_medieval_hexagon_pack/`.

***

### sha256

[Section titled “sha256”](#sha256)

> `readonly` **sha256**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:158](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L158)

SHA-256 hash of the file’s contents, lowercase hex.

# BootstrapKayKitAssetsOptions

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:95](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L95)

Inputs to [bootstrapKayKitAssets](/declarative-hex-worlds/reference/cli/commands/bootstrap/functions/bootstrapkaykitassets/).

## Properties

[Section titled “Properties”](#properties)

### edition?

[Section titled “edition?”](#edition)

> `readonly` `optional` **edition?**: `"free"` | `"extra"`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:104](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L104)

Pack edition (default `free`). `extra` requires `source.kind === 'zip'`.

***

### fetchedAt?

[Section titled “fetchedAt?”](#fetchedat)

> `readonly` `optional` **fetchedAt?**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:125](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L125)

Reproducible timestamp written into the integrity sidecar. Default `new Date().toISOString()`.

***

### force?

[Section titled “force?”](#force)

> `readonly` `optional` **force?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:110](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L110)

When true, the destination is wiped before mirroring. When false (default), an existing non-empty target throws unless its sidecar matches the requested edition.

***

### githubSource?

[Section titled “githubSource?”](#githubsource)

> `readonly` `optional` **githubSource?**: `object`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:143](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L143)

GitHub archive source for the pack (RFC0-10). Defaults to the KayKit Medieval Hexagon repo. Pass a pack descriptor’s `github` to fetch a different pack’s archive. Only used when `source.kind === 'github'`.

#### archiveUrlTemplate

[Section titled “archiveUrlTemplate”](#archiveurltemplate)

> `readonly` **archiveUrlTemplate**: `string`

#### defaultRef

[Section titled “defaultRef”](#defaultref)

> `readonly` **defaultRef**: `string`

#### owner

[Section titled “owner”](#owner)

> `readonly` **owner**: `string`

#### repo

[Section titled “repo”](#repo)

> `readonly` **repo**: `string`

***

### includeSourceFormats?

[Section titled “includeSourceFormats?”](#includesourceformats)

> `readonly` `optional` **includeSourceFormats?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:115](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L115)

Include `.fbx`, `.fbx(unity)`, `.obj`, `.mtl` files. Default false — only `.gltf`, `.bin`, and PNG textures are mirrored.

***

### layout?

[Section titled “layout?”](#layout)

> `readonly` `optional` **layout?**: [`KayKitUpstreamLayout`](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/)

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:137](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L137)

Target upstream layout (RFC0-10). Defaults to the edition-derived KayKit Medieval Hexagon layout. Pass a `characterPackLayout(...)` to bootstrap a character pack (Adventurers/Skeletons) instead. When set, detection and mirroring use THIS layout rather than the medieval-hexagon detection list.

***

### libraryVersion?

[Section titled “libraryVersion?”](#libraryversion)

> `readonly` `optional` **libraryVersion?**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L130)

Override for the integrity sidecar’s `libraryVersion` field. Defaults to the value resolved from the closest `package.json`.

***

### out

[Section titled “out”](#out)

> `readonly` **out**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:102](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L102)

Consumer’s asset root. The bootstrap step writes `<out>/addons/kaykit_medieval_hexagon_pack/...` under this folder.

***

### outRoot?

[Section titled “outRoot?”](#outroot)

> `readonly` `optional` **outRoot?**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:120](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L120)

Optional jail root for `out` resolution. Defaults to `process.cwd()`. The bootstrap function refuses to write outside this root.

***

### source

[Section titled “source”](#source)

> `readonly` **source**: [`BootstrapKayKitAssetsSource`](/declarative-hex-worlds/reference/cli/commands/bootstrap/type-aliases/bootstrapkaykitassetssource/)

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:97](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L97)

Where to fetch the upstream source tree from.

# BootstrapPackOptions

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:51](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L51)

Options for [bootstrapPack](/declarative-hex-worlds/reference/cli/commands/bootstrap/functions/bootstrappack/).

## Properties

[Section titled “Properties”](#properties)

### fetchedAt?

[Section titled “fetchedAt?”](#fetchedat)

> `readonly` `optional` **fetchedAt?**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L65)

Reproducible sidecar timestamp (tests).

***

### force?

[Section titled “force?”](#force)

> `readonly` `optional` **force?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:63](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L63)

Overwrite an existing non-empty target.

***

### libraryVersion?

[Section titled “libraryVersion?”](#libraryversion)

> `readonly` `optional` **libraryVersion?**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L67)

Sidecar library-version override (tests).

***

### outRoot?

[Section titled “outRoot?”](#outroot)

> `readonly` `optional` **outRoot?**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:59](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L59)

Jail root for path resolution (defaults to cwd inside core).

***

### rawAssetsRoot

[Section titled “rawAssetsRoot”](#rawassetsroot)

> `readonly` **rawAssetsRoot**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:57](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L57)

Gitignored raw-assets ROOT. The pack materializes into `<rawAssetsRoot>/<packId>/` — the id subdir is appended internally so the write location always matches [resolveDefaultPackKit](/declarative-hex-worlds/reference/cli/commands/bootstrap/functions/resolvedefaultpackkit/)/[assertPackPresent](/declarative-hex-worlds/reference/cli/commands/bootstrap/functions/assertpackpresent/).

***

### ref?

[Section titled “ref?”](#ref)

> `readonly` `optional` **ref?**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:61](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L61)

Git ref to fetch (defaults to the descriptor’s default ref).

# BootstrapResult

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:185](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L185)

Return value of [bootstrapKayKitAssets](/declarative-hex-worlds/reference/cli/commands/bootstrap/functions/bootstrapkaykitassets/).

## Properties

[Section titled “Properties”](#properties)

### edition

[Section titled “edition”](#edition)

> `readonly` **edition**: `"free"` | `"extra"`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:187](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L187)

Pack edition that was bootstrapped.

***

### fileCount

[Section titled “fileCount”](#filecount)

> `readonly` **fileCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:191](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L191)

Total number of files written (gltf + bin + textures + any extras).

***

### integritySidecar

[Section titled “integritySidecar”](#integritysidecar)

> `readonly` **integritySidecar**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:195](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L195)

Absolute path of the integrity sidecar.

***

### outRoot

[Section titled “outRoot”](#outroot)

> `readonly` **outRoot**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:189](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L189)

Absolute path of the bootstrap target root.

***

### totalBytes

[Section titled “totalBytes”](#totalbytes)

> `readonly` **totalBytes**: `number`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:193](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L193)

Sum of [BootstrapFileEntry.bytes](/declarative-hex-worlds/reference/cli/commands/bootstrap/interfaces/bootstrapfileentry/#bytes).

# BootstrapSidecar

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:167](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L167)

Integrity sidecar serialized as `.bootstrap.json` inside each bootstrap target.

## Properties

[Section titled “Properties”](#properties)

### edition

[Section titled “edition”](#edition)

> `readonly` **edition**: `"free"` | `"extra"`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:171](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L171)

Pack edition this target was bootstrapped for.

***

### fetchedAt

[Section titled “fetchedAt”](#fetchedat)

> `readonly` **fetchedAt**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:177](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L177)

ISO-8601 timestamp at which the bootstrap was performed.

***

### files

[Section titled “files”](#files)

> `readonly` **files**: readonly [`BootstrapFileEntry`](/declarative-hex-worlds/reference/cli/commands/bootstrap/interfaces/bootstrapfileentry/)\[]

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:179](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L179)

Sorted list of every mirrored file plus its SHA-256.

***

### libraryVersion

[Section titled “libraryVersion”](#libraryversion)

> `readonly` **libraryVersion**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:173](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L173)

Library version that produced this bootstrap.

***

### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> `readonly` **schemaVersion**: `"1.0.0"`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:169](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L169)

Sidecar schema version.

***

### sourceUrl

[Section titled “sourceUrl”](#sourceurl)

> `readonly` **sourceUrl**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:175](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L175)

Provenance URL (https\://…) or `file://` URL for zip-sourced bootstraps.

# BootstrapVerificationReport

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:201](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L201)

Verification report returned by [verifyBootstrap](/declarative-hex-worlds/reference/cli/commands/bootstrap/functions/verifybootstrap/).

## Properties

[Section titled “Properties”](#properties)

### drift

[Section titled “drift”](#drift)

> `readonly` **drift**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:205](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L205)

Human-readable descriptions of any drift discovered.

***

### ok

[Section titled “ok”](#ok)

> `readonly` **ok**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:203](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L203)

True when every recorded file matches its expected hash and length.

***

### sidecarPath

[Section titled “sidecarPath”](#sidecarpath)

> `readonly` **sidecarPath**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:207](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L207)

Sidecar that was checked.

# PackResolution

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:104](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L104)

A pack’s default-resolution status against a raw-assets root.

## Properties

[Section titled “Properties”](#properties)

### dir

[Section titled “dir”](#dir)

> `readonly` **dir**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:108](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L108)

Absolute directory the pack resolves to (whether or not it’s present).

***

### id

[Section titled “id”](#id)

> `readonly` **id**: `"medieval-hexagon"` | `"adventurers"` | `"skeletons"`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:106](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L106)

Pack id.

***

### present

[Section titled “present”](#present)

> `readonly` **present**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts:110](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/pack-bootstrap.ts#L110)

True when the pack is materialized there.

# BootstrapKayKitAssetsSource

> **BootstrapKayKitAssetsSource** = { `commit?`: `string`; `kind`: `"github"`; } | { `kind`: `"zip"`; `path`: `string`; }

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:78](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L78)

Source descriptor for [BootstrapKayKitAssetsOptions](/declarative-hex-worlds/reference/cli/commands/bootstrap/interfaces/bootstrapkaykitassetsoptions/). Discriminates between fetching from the upstream GitHub repo and extracting a locally cached zip archive.

## Union Members

[Section titled “Union Members”](#union-members)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `commit?`: `string`; `kind`: `"github"`; }

#### commit?

[Section titled “commit?”](#commit)

> `readonly` `optional` **commit?**: `string`

Optional git ref (commit / tag / branch). Defaults to [KAYKIT\_FREE\_GITHUB\_DEFAULT\_REF](/declarative-hex-worlds/reference/cli/commands/bootstrap/variables/kaykit_free_github_default_ref/).

#### kind

[Section titled “kind”](#kind)

> `readonly` **kind**: `"github"`

Source kind discriminator selecting the upstream-GitHub tarball path.

***

### Type Literal

[Section titled “Type Literal”](#type-literal-1)

{ `kind`: `"zip"`; `path`: `string`; }

#### kind

[Section titled “kind”](#kind-1)

> `readonly` **kind**: `"zip"`

Source kind discriminator selecting the local-zip extraction path.

#### path

[Section titled “path”](#path)

> `readonly` **path**: `string`

Filesystem path of the locally cached pack zip.

# PackCategory

> **PackCategory** = *typeof* [`PACK_CATEGORIES`](/declarative-hex-worlds/reference/cli/commands/bootstrap/variables/pack_categories/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts:38](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts#L38)

Gameplay category a pack fills.

# PackDescriptor

> **PackDescriptor** = `z.infer`<*typeof* [`packDescriptorSchema`](/declarative-hex-worlds/reference/cli/commands/bootstrap/variables/packdescriptorschema/)>

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts:75](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts#L75)

A downloadable-pack descriptor.

# PackGithubSource

> **PackGithubSource** = `z.infer`<*typeof* [`packGithubSourceSchema`](/declarative-hex-worlds/reference/cli/commands/bootstrap/variables/packgithubsourceschema/)>

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts:55](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts#L55)

Upstream GitHub source descriptor.

# PackId

> **PackId** = *typeof* [`PACK_IDS`](/declarative-hex-worlds/reference/cli/commands/bootstrap/variables/pack_ids/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts:25](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts#L25)

One of the recognized downloadable pack ids.

# PackRole

> **PackRole** = *typeof* [`PACK_ROLES`](/declarative-hex-worlds/reference/cli/commands/bootstrap/variables/pack_roles/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts:30](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts#L30)

Asset role a pack contributes (tiles vs models).

# characterPackLayout

> **characterPackLayout**(`packFolderName`): [`KayKitUpstreamLayout`](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/)

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:120](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L120)

Build an upstream layout for a KayKit CHARACTER pack (Adventurers, Skeletons — RFC0-10). Verified against the cloned repos: a character pack has TWO renderable gltf trees under `addons/<packFolderName>/` — `Assets/gltf/` (weapons/accessories) and `Characters/gltf/` (the `.glb` character bodies with embedded textures). `detection: 'character'` matches on “the `Assets/gltf` root exists with ≥1 `.gltf`/`.glb`”; `mirrorAllGltfDirs: true` then makes the mirror SCAN for every renderable-gltf directory (so `Characters/gltf/` is captured too — a single hardcoded root dropped the bodies). Counts are 0 (irrelevant for character packs); the mirror walks recursively regardless.

## Parameters

[Section titled “Parameters”](#parameters)

### packFolderName

[Section titled “packFolderName”](#packfoldername)

`string`

## Returns

[Section titled “Returns”](#returns)

[`KayKitUpstreamLayout`](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/)

# detectKayKitLayout

> **detectKayKitLayout**(`rootPath`): [`KayKitUpstreamLayout`](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:155](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L155)

Inspect a candidate pack root and return its matching layout descriptor.

Detection rule: a candidate matches a layout when the GLTF category directories exist AND at least one of two provenance signals is present: A) All [KayKitUpstreamLayout.markerFiles](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/#markerfiles) exist (itch.io zip). B) The primary texture file exists under [KayKitUpstreamLayout.relativeTextureRoot](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/#relativetextureroot) (GitHub archive — omits `License.txt`, PDFs, and `contents_*.jpg` but includes the texture). EXTRA is tested before FREE (EXTRA categories are a superset of FREE’s).

## Parameters

[Section titled “Parameters”](#parameters)

### rootPath

[Section titled “rootPath”](#rootpath)

`string`

## Returns

[Section titled “Returns”](#returns)

[`KayKitUpstreamLayout`](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/) | `undefined`

# detectLayoutFrom

> **detectLayoutFrom**(`rootPath`, `candidates`): [`KayKitUpstreamLayout`](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:165](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L165)

Detect which of the given candidate layouts a pack root matches (RFC0-10). `detectKayKitLayout` is the medieval-hexagon-only default; the pack bootstrap passes its specific target layout (e.g. a character-pack layout) so a non-medieval pack is detected against the right shape.

## Parameters

[Section titled “Parameters”](#parameters)

### rootPath

[Section titled “rootPath”](#rootpath)

`string`

### candidates

[Section titled “candidates”](#candidates)

readonly [`KayKitUpstreamLayout`](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/)\[]

## Returns

[Section titled “Returns”](#returns)

[`KayKitUpstreamLayout`](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/) | `undefined`

# expectedTexturePaths

> **expectedTexturePaths**(`rootPath`, `layout`): readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:185](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L185)

List the texture files that should appear under `<root>/<relativeTextureRoot>` for a given layout. Returns the absolute paths so callers can verify presence + checksum.

## Parameters

[Section titled “Parameters”](#parameters)

### rootPath

[Section titled “rootPath”](#rootpath)

`string`

### layout

[Section titled “layout”](#layout)

[`KayKitUpstreamLayout`](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/)

## Returns

[Section titled “Returns”](#returns)

readonly `string`\[]

# kayKitLayoutForEdition

> **kayKitLayoutForEdition**(`edition`): [`KayKitUpstreamLayout`](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/)

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:140](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L140)

Resolve the canonical layout descriptor for a known pack edition.

## Parameters

[Section titled “Parameters”](#parameters)

### edition

[Section titled “edition”](#edition)

`"free"` | `"extra"`

## Returns

[Section titled “Returns”](#returns)

[`KayKitUpstreamLayout`](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/)

# KayKitUpstreamLayout

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:42](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L42)

Structural description of a single KayKit Medieval Hexagon pack edition as it appears on disk after extraction.

## Properties

[Section titled “Properties”](#properties)

### assetCategories

[Section titled “assetCategories”](#assetcategories)

> `readonly` **assetCategories**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:54](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L54)

Asset category subdirectory names found directly under [relativeGltfRoot](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/#relativegltfroot).

***

### detection?

[Section titled “detection?”](#detection)

> `readonly` `optional` **detection?**: `"medieval"` | `"character"`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:70](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L70)

Detection strategy (RFC0-10). `'medieval'` (default) uses the marker/texture + required-category rules below — the Medieval Hexagon shape. `'character'` matches a flat `Assets/gltf/` with ≥1 `.gltf` and no category/marker requirements — the KayKit character packs (Adventurers/Skeletons), which ship textures inline in `Assets/gltf/` and carry no edition markers.

***

### displayName

[Section titled “displayName”](#displayname)

> `readonly` **displayName**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:46](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L46)

Human-readable edition label (e.g. `FREE`, `EXTRA`).

***

### editionName

[Section titled “editionName”](#editionname)

> `readonly` **editionName**: `"free"` | `"extra"`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:44](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L44)

Edition this layout describes.

***

### expectedBinCount

[Section titled “expectedBinCount”](#expectedbincount)

> `readonly` **expectedBinCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:60](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L60)

Expected total number of `.bin` companions under [relativeGltfRoot](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/#relativegltfroot).

***

### expectedGltfCount

[Section titled “expectedGltfCount”](#expectedgltfcount)

> `readonly` **expectedGltfCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L58)

Expected total number of `.gltf` files under [relativeGltfRoot](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/#relativegltfroot).

***

### markerFiles

[Section titled “markerFiles”](#markerfiles)

> `readonly` **markerFiles**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:56](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L56)

Files used as markers when detecting which edition a pack root belongs to.

***

### mirrorAllGltfDirs?

[Section titled “mirrorAllGltfDirs?”](#mirrorallgltfdirs)

> `readonly` `optional` **mirrorAllGltfDirs?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:80](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L80)

When `true`, the mirror ignores [relativeGltfRoot](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/#relativegltfroot) as a single source and instead SCANS the pack root for every directory containing a renderable `.gltf`/`.glb`, mirroring each (path preserved relative to the pack root). This is how a character pack captures BOTH `Assets/gltf/` (weapons) and `Characters/gltf/` (bodies) — the layout is derived from the real tree, not a declared constant. Source-format dirs (`fbx`, `obj`, `Samples`) are excluded by extension/name during the walk.

***

### packFolderName

[Section titled “packFolderName”](#packfoldername)

> `readonly` **packFolderName**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:48](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L48)

Top-level pack folder name as published by KayKit.

***

### relativeGltfRoot

[Section titled “relativeGltfRoot”](#relativegltfroot)

> `readonly` **relativeGltfRoot**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:50](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L50)

Relative path under the pack root where `.gltf` assets live.

***

### relativeTextureRoot

[Section titled “relativeTextureRoot”](#relativetextureroot)

> `readonly` **relativeTextureRoot**: `string`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:52](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L52)

Relative path under the pack root where shared `.png` textures live.

***

### textureFiles

[Section titled “textureFiles”](#texturefiles)

> `readonly` **textureFiles**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:62](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L62)

Texture filenames published with this edition’s `Textures/` directory.

# KAYKIT_MEDIEVAL_EXTRA_LAYOUT

> `const` **KAYKIT\_MEDIEVAL\_EXTRA\_LAYOUT**: [`KayKitUpstreamLayout`](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/) = `UPSTREAM_LAYOUTS.extra`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:99](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L99)

KayKit Medieval Hexagon Pack — EXTRA edition layout (purchased on itch.io).

Adds the `units/` category, three seasonal texture variants, and a `contents_units.jpg` + `contents_textures.jpg` marker pair. Otherwise structurally identical to the FREE edition. Sourced from `src/config/upstream-layouts.json`.

# KAYKIT_MEDIEVAL_FREE_LAYOUT

> `const` **KAYKIT\_MEDIEVAL\_FREE\_LAYOUT**: [`KayKitUpstreamLayout`](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/) = `UPSTREAM_LAYOUTS.free`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:89](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L89)

KayKit Medieval Hexagon Pack — FREE edition layout (CC0).

Mirrors `https://github.com/KayKit-Game-Assets/KayKit-Medieval-Hexagon-Pack-1.0`. Values are sourced from `src/config/upstream-layouts.json`.

# KAYKIT_UPSTREAM_LAYOUTS

> `const` **KAYKIT\_UPSTREAM\_LAYOUTS**: readonly [`KayKitUpstreamLayout`](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/interfaces/kaykitupstreamlayout/)\[]

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts:104](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/upstream-layout.ts#L104)

All supported KayKit upstream layouts, in declaration order.

# KAYKIT_BOOTSTRAP_GLTF_RELATIVE

> `const` **KAYKIT\_BOOTSTRAP\_GLTF\_RELATIVE**: `string` = `BOOTSTRAP_PATHS.gltfRelative`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/target.ts:14](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/target.ts#L14)

Sub-folder under the consumer’s asset root holding the mirrored GLTF tree. Empty string means GLTFs land directly in the asset root (flat layout).

# KAYKIT_BOOTSTRAP_SIDECAR

> `const` **KAYKIT\_BOOTSTRAP\_SIDECAR**: `string` = `BOOTSTRAP_PATHS.sidecarFileName`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/target.ts:24](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/target.ts#L24)

Filename of the integrity sidecar written into each bootstrap target.

# KAYKIT_BOOTSTRAP_TEXTURE_RELATIVE

> `const` **KAYKIT\_BOOTSTRAP\_TEXTURE\_RELATIVE**: `string` = `BOOTSTRAP_PATHS.textureRelative`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/target.ts:19](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/target.ts#L19)

Sub-folder under the consumer’s asset root holding mirrored shared textures.

# KAYKIT_FREE_GITHUB_DEFAULT_REF

> `const` **KAYKIT\_FREE\_GITHUB\_DEFAULT\_REF**: `string` = `KAYKIT_SOURCE.github.defaultRef`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:71](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L71)

Default git ref the bootstrap CLI fetches when no `--commit` is supplied.

# KAYKIT_FREE_GITHUB_OWNER

> `const` **KAYKIT\_FREE\_GITHUB\_OWNER**: `string` = `KAYKIT_SOURCE.github.owner`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:60](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L60)

Canonical GitHub organization holding the FREE edition source tree.

# KAYKIT_FREE_GITHUB_REPO

> `const` **KAYKIT\_FREE\_GITHUB\_REPO**: `string` = `KAYKIT_SOURCE.github.repo`

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts:66](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/core.ts#L66)

Canonical GitHub repository name for the FREE edition (the repo at `KayKit-Game-Assets/KayKit-Medieval-Hexagon-Pack-1.0`).

# PACK_CATEGORIES

> `const` **PACK\_CATEGORIES**: readonly \[`"terrain"`, `"playable"`, `"enemy"`]

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts:36](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts#L36)

Gameplay category a pack fills — drives default source composition (terrain board vs playable units vs enemies) so three packs compose into a full game.

# PACK_IDS

> `const` **PACK\_IDS**: readonly \[`"medieval-hexagon"`, `"adventurers"`, `"skeletons"`]

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts:23](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts#L23)

A stable pack identifier used by the CLI (`bootstrap --pack <id>`) and resolution.

# PACK_REGISTRY

> `const` **PACK\_REGISTRY**: `Readonly`<`Record`<[`PackId`](/declarative-hex-worlds/reference/cli/commands/bootstrap/type-aliases/packid/), [`PackDescriptor`](/declarative-hex-worlds/reference/cli/commands/bootstrap/type-aliases/packdescriptor/)>>

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts#L86)

The three first-class downloadable CC0 packs. Together they are a full game from defaults: a hex tile board, playable characters, and enemies. GitHub reports these repos as NOASSERTION (no machine-readable LICENSE), but KayKit’s itch.io pages license the packs CC0; the attribution is a courtesy credit.

# PACK_ROLES

> `const` **PACK\_ROLES**: readonly \[`"tile"`, `"model"`]

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts:28](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts#L28)

How a pack’s assets map into an AssetSource role.

# packDescriptorSchema

> `const` **packDescriptorSchema**: `ZodObject`<{ `attribution`: `ZodString`; `category`: `ZodEnum`<{ `enemy`: `"enemy"`; `playable`: `"playable"`; `terrain`: `"terrain"`; }>; `displayName`: `ZodString`; `github`: `ZodObject`<{ `archiveUrlTemplate`: `ZodString`; `defaultRef`: `ZodString`; `owner`: `ZodString`; `repo`: `ZodString`; }, `$strip`>; `id`: `ZodEnum`<{ `adventurers`: `"adventurers"`; `medieval-hexagon`: `"medieval-hexagon"`; `skeletons`: `"skeletons"`; }>; `packFolder`: `ZodString`; `role`: `ZodEnum`<{ `model`: `"model"`; `tile`: `"tile"`; }>; }, `$strip`>

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts#L58)

A single downloadable-pack descriptor.

# packGithubSourceSchema

> `const` **packGithubSourceSchema**: `ZodObject`<{ `archiveUrlTemplate`: `ZodString`; `defaultRef`: `ZodString`; `owner`: `ZodString`; `repo`: `ZodString`; }, `$strip`>

Defined in: [packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts:41](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/cli/commands/bootstrap/registry.ts#L41)

Upstream GitHub source for a pack’s CC0 archive.

# axialToWorld

> **axialToWorld**(`coordinates`, `elevation?`, `geometry?`): [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:185](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L185)

Converts axial hex coordinates to KayKit world-space coordinates.

## Parameters

[Section titled “Parameters”](#parameters)

### coordinates

[Section titled “coordinates”](#coordinates)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### elevation?

[Section titled “elevation?”](#elevation)

`number` = `0`

### geometry?

[Section titled “geometry?”](#geometry)

[`HexGeometry`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/hexgeometry/) = `DEFAULT_HEX_GEOMETRY`

## Returns

[Section titled “Returns”](#returns)

[`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

# createGameboardCoordinateSystem

> **createGameboardCoordinateSystem**(`options?`): [`GameboardCoordinateSystem`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/gameboardcoordinatesystem/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:209](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L209)

Creates a reusable coordinate-system facade for grid math, paths, and spawns.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`GameboardCoordinateSystemOptions`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/gameboardcoordinatesystemoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardCoordinateSystem`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/gameboardcoordinatesystem/)

# createGameboardGrid

> **createGameboardGrid**(`shape`): [`KayKitGameboardGrid`](/declarative-hex-worlds/reference/coordinates/grid/type-aliases/kaykitgameboardgrid/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:178](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L178)

Creates a Honeycomb grid for any supported gameboard shape.

## Parameters

[Section titled “Parameters”](#parameters)

### shape

[Section titled “shape”](#shape)

[`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

## Returns

[Section titled “Returns”](#returns)

[`KayKitGameboardGrid`](/declarative-hex-worlds/reference/coordinates/grid/type-aliases/kaykitgameboardgrid/)

# createHexagonGameboardGrid

> **createHexagonGameboardGrid**(`options`): [`KayKitGameboardGrid`](/declarative-hex-worlds/reference/coordinates/grid/type-aliases/kaykitgameboardgrid/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:173](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L173)

Creates a hexagonal Honeycomb spiral grid using KayKit hex dimensions.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`HexagonGridOptions`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/hexagongridoptions/)

## Returns

[Section titled “Returns”](#returns)

[`KayKitGameboardGrid`](/declarative-hex-worlds/reference/coordinates/grid/type-aliases/kaykitgameboardgrid/)

# createRectangleGameboardGrid

> **createRectangleGameboardGrid**(`options`): `Grid`<`Hex`>

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:166](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L166)

Creates a rectangular Honeycomb grid using KayKit hex dimensions.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`RectangleGridOptions`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/rectanglegridoptions/)

## Returns

[Section titled “Returns”](#returns)

`Grid`<`Hex`>

# createSpawnLocations

> **createSpawnLocations**(`options?`): [`SpawnLocation`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocation/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:234](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L234)

Selects deterministic spawn coordinates and projects them to world positions.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`SpawnLocationOptions`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocationoptions/) & `object` = `...`

## Returns

[Section titled “Returns”](#returns)

[`SpawnLocation`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocation/)\[]

# rowSpacingForGeometry

> **rowSpacingForGeometry**(`geometry`): `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:250](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L250)

Computes row spacing from hex depth for pointy hex placement.

## Parameters

[Section titled “Parameters”](#parameters)

### geometry

[Section titled “geometry”](#geometry)

`Pick`<[`HexGeometry`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/hexgeometry/), `"depth"`>

## Returns

[Section titled “Returns”](#returns)

`number`

# worldToAxial

> **worldToAxial**(`position`, `geometry?`): [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:199](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L199)

Converts world X/Z coordinates to the nearest axial hex coordinate.

## Parameters

[Section titled “Parameters”](#parameters)

### position

[Section titled “position”](#position)

`Pick`<[`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/), `"x"` | `"z"`>

### geometry?

[Section titled “geometry?”](#geometry)

[`HexGeometry`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/hexgeometry/) = `DEFAULT_HEX_GEOMETRY`

## Returns

[Section titled “Returns”](#returns)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

# GameboardCoordinateSystem

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:107](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L107)

Convenience surface for KayKit-compatible coordinate math.

## Properties

[Section titled “Properties”](#properties)

### distance

[Section titled “distance”](#distance)

> **distance**: (`left`, `right`) => `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:119](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L119)

Computes axial hex distance between two coordinates.

#### Parameters

[Section titled “Parameters”](#parameters)

##### left

[Section titled “left”](#left)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### right

[Section titled “right”](#right)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns)

`number`

***

### findPath

[Section titled “findPath”](#findpath)

> **findPath**: (`start`, `goal`, `options?`) => [`HexPathResult`](/declarative-hex-worlds/reference/index/interfaces/hexpathresult/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:121](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L121)

Finds a path between two coordinates using the shared pathfinding helper.

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### start

[Section titled “start”](#start)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### goal

[Section titled “goal”](#goal)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### options?

[Section titled “options?”](#options)

[`HexPathOptions`](/declarative-hex-worlds/reference/index/interfaces/hexpathoptions/)

#### Returns

[Section titled “Returns”](#returns-1)

[`HexPathResult`](/declarative-hex-worlds/reference/index/interfaces/hexpathresult/)

***

### fromWorld

[Section titled “fromWorld”](#fromworld)

> **fromWorld**: (`position`) => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:115](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L115)

Converts a world X/Z position to the nearest axial coordinate.

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### position

[Section titled “position”](#position)

`Pick`<[`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/), `"x"` | `"z"`>

#### Returns

[Section titled “Returns”](#returns-2)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

***

### geometry

[Section titled “geometry”](#geometry)

> **geometry**: [`HexGeometry`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/hexgeometry/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:109](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L109)

Geometry used by all conversions in this coordinate system.

***

### neighbors

[Section titled “neighbors”](#neighbors)

> **neighbors**: (`coordinates`) => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:117](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L117)

Returns the six axial neighbors around a coordinate.

#### Parameters

[Section titled “Parameters”](#parameters-3)

##### coordinates

[Section titled “coordinates”](#coordinates)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns-3)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

***

### rowSpacing

[Section titled “rowSpacing”](#rowspacing)

> **rowSpacing**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:111](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L111)

Z-axis spacing between adjacent hex rows.

***

### spawnLocations

[Section titled “spawnLocations”](#spawnlocations)

> **spawnLocations**: (`options`) => [`SpawnLocation`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocation/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:127](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L127)

Selects deterministic spawn locations and projects them into world space.

#### Parameters

[Section titled “Parameters”](#parameters-4)

##### options

[Section titled “options”](#options-1)

[`SpawnLocationOptions`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocationoptions/)

#### Returns

[Section titled “Returns”](#returns-4)

[`SpawnLocation`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocation/)\[]

***

### toWorld

[Section titled “toWorld”](#toworld)

> **toWorld**: (`coordinates`, `elevation?`) => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:113](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L113)

Converts an axial coordinate and optional elevation into world space.

#### Parameters

[Section titled “Parameters”](#parameters-5)

##### coordinates

[Section titled “coordinates”](#coordinates-1)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### elevation?

[Section titled “elevation?”](#elevation)

`number`

#### Returns

[Section titled “Returns”](#returns-5)

[`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

# GameboardCoordinateSystemOptions

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L67)

Options for creating a reusable coordinate conversion system.

## Properties

[Section titled “Properties”](#properties)

### geometry?

[Section titled “geometry?”](#geometry)

> `optional` **geometry?**: `Partial`<[`HexGeometry`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/hexgeometry/)>

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:69](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L69)

Geometry override for non-KayKit or rescaled boards.

# HexagonGridOptions

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:154](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L154)

Hexagon grid dimensions in rings around the origin.

## Properties

[Section titled “Properties”](#properties)

### radius

[Section titled “radius”](#radius)

> **radius**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:156](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L156)

Honeycomb spiral radius.

# HexGeometry

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:24](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L24)

World-space dimensions for a hex footprint.

## Properties

[Section titled “Properties”](#properties)

### depth

[Section titled “depth”](#depth)

> **depth**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:28](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L28)

Tile depth along the world Z axis.

***

### elevationStep

[Section titled “elevationStep”](#elevationstep)

> **elevationStep**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:30](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L30)

Vertical world-unit step for one elevation level.

***

### width

[Section titled “width”](#width)

> **width**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:26](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L26)

Tile width along the world X axis.

# RectangleGridOptions

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:146](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L146)

Rectangle grid dimensions in hex cells.

## Properties

[Section titled “Properties”](#properties)

### height

[Section titled “height”](#height)

> **height**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:150](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L150)

Number of rows in the rectangle.

***

### width

[Section titled “width”](#width)

> **width**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:148](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L148)

Number of columns in the rectangle.

# SpawnLocation

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:95](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L95)

Spawn point with both hex-grid and world-space coordinates.

## Properties

[Section titled “Properties”](#properties)

### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:101](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L101)

Selected axial coordinate.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:97](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L97)

Stable generated spawn id.

***

### key

[Section titled “key”](#key)

> **key**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:99](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L99)

Hex coordinate key for map/set lookups.

***

### position

[Section titled “position”](#position)

> **position**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:103](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L103)

World-space position for placing a unit or marker.

# SpawnLocationOptions

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:73](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L73)

Options for deterministic spawn coordinate selection and projection.

## Properties

[Section titled “Properties”](#properties)

### candidates?

[Section titled “candidates?”](#candidates)

> `optional` **candidates?**: readonly [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:81](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L81)

Explicit candidate coordinates to choose from instead of the whole shape.

***

### count

[Section titled “count”](#count)

> **count**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:77](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L77)

Number of spawn locations to return.

***

### edgePadding?

[Section titled “edgePadding?”](#edgepadding)

> `optional` **edgePadding?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:87](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L87)

Number of outer rings/rows to avoid when selecting automatic candidates.

***

### elevation?

[Section titled “elevation?”](#elevation)

> `optional` **elevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:89](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L89)

Elevation used when projecting spawn locations to world positions.

***

### idPrefix?

[Section titled “idPrefix?”](#idprefix)

> `optional` **idPrefix?**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:91](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L91)

Prefix used for generated spawn ids.

***

### minDistance?

[Section titled “minDistance?”](#mindistance)

> `optional` **minDistance?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:85](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L85)

Minimum axial distance between returned spawn coordinates.

***

### passable?

[Section titled “passable?”](#passable)

> `optional` **passable?**: (`coordinates`) => `boolean`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:83](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L83)

Predicate used to reject blocked or otherwise unsuitable coordinates.

#### Parameters

[Section titled “Parameters”](#parameters)

##### coordinates

[Section titled “coordinates”](#coordinates)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns)

`boolean`

***

### seed?

[Section titled “seed?”](#seed)

> `optional` **seed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:79](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L79)

Seed used when candidate order must be randomized.

***

### shape

[Section titled “shape”](#shape)

> **shape**: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:75](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L75)

Board shape to select candidate spawn coordinates from.

# GameboardGridOptions

> **GameboardGridOptions** = [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:160](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L160)

Supported board shapes for Honeycomb grid creation.

# HexOrientation

> **HexOrientation** = `"pointy"` | `"flat"`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:21](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L21)

Hex vertex orientation: `'pointy'` (vertex up) or `'flat'` (edge up).

# KayKitGameboardGrid

> **KayKitGameboardGrid** = `Grid`<`InstanceType`<*typeof* [`KayKitHex`](/declarative-hex-worlds/reference/coordinates/grid/variables/kaykithex/)>>

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:163](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L163)

Honeycomb grid instance configured with the KayKit hex class.

# DEFAULT_HEX_GEOMETRY

> `const` **DEFAULT\_HEX\_GEOMETRY**: [`HexGeometry`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/hexgeometry/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:40](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L40)

The DEFAULT hex-grid world geometry, loaded from `hex-geometry.default.json` — DATA, not an engine constant. The agnostic core hardcodes NO pack’s numbers; a board/pack overrides these via `createGameboardCoordinateSystem({ geometry })` or a tileset source’s `hex`. The shipped defaults match the KayKit Medieval Hexagon reference pack, but that’s just the default data, not a baked-in assumption.

# DEFAULT_HEX_ORIENTATION

> `const` **DEFAULT\_HEX\_ORIENTATION**: [`HexOrientation`](/declarative-hex-worlds/reference/coordinates/grid/type-aliases/hexorientation/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L47)

Default hex orientation (from the geometry defaults data).

# KAYKIT_ELEVATION_STEP

> `const` **KAYKIT\_ELEVATION\_STEP**: `number` = `DEFAULT_HEX_GEOMETRY.elevationStep`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:64](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L64)

Deprecated

Use `DEFAULT_HEX_GEOMETRY.elevationStep`.

# KAYKIT_HEX_DEPTH

> `const` **KAYKIT\_HEX\_DEPTH**: `number` = `DEFAULT_HEX_GEOMETRY.depth`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L58)

Deprecated

Use `DEFAULT_HEX_GEOMETRY.depth`.

# KAYKIT_HEX_GEOMETRY

> `const` **KAYKIT\_HEX\_GEOMETRY**: [`HexGeometry`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/hexgeometry/) = `DEFAULT_HEX_GEOMETRY`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L134)

Deprecated

Alias of `DEFAULT_HEX_GEOMETRY` (data-driven). Use that instead of the KayKit-named export — the engine holds no pack-specific geometry.

# KAYKIT_HEX_ROW_SPACING

> `const` **KAYKIT\_HEX\_ROW\_SPACING**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:62](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L62)

Deprecated

Row spacing derives from geometry; use `rowSpacingForGeometry(DEFAULT_HEX_GEOMETRY)`.

# KAYKIT_HEX_SIDE

> `const` **KAYKIT\_HEX\_SIDE**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:60](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L60)

Deprecated

Use `DEFAULT_HEX_GEOMETRY.depth / 2`.

# KAYKIT_HEX_WIDTH

> `const` **KAYKIT\_HEX\_WIDTH**: `number` = `DEFAULT_HEX_GEOMETRY.width`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:56](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L56)

Back-compat aliases for the default geometry, now SOURCED FROM the JSON defaults (not hardcoded). Prefer `DEFAULT_HEX_GEOMETRY` in new code; these remain so existing consumers keep working.

Deprecated

Use `DEFAULT_HEX_GEOMETRY` (data-driven) instead of the KayKit-named constants.

# KayKitHex

> `const` **KayKitHex**: *typeof* `Hex`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:137](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L137)

Honeycomb hex class configured for the default axial footprint.

# analyzeGameboardLayoutFill

> **analyzeGameboardLayoutFill**(`plan`, `options`): [`GameboardLayoutFillAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillanalysis/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:981](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L981)

Analyze layout fill rules, selected sites, and diagnostics without mutating a world or requiring render assets.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### options

[Section titled “options”](#options)

[`GameboardLayoutFillOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfilloptions/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardLayoutFillAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillanalysis/)

# appendGameboardLayoutPlacementsToPlan

> **appendGameboardLayoutPlacementsToPlan**(`plan`, `placements`): [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:1795](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L1795)

Return a copied plan with generated layout placements appended as concrete placement specs.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### placements

[Section titled “placements”](#placements)

readonly [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

# createGameboardLayoutArchetypeRegistry

> **createGameboardLayoutArchetypeRegistry**(`archetypes?`, `options?`): [`GameboardLayoutArchetypeRegistry`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetyperegistry/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:689](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L689)

Create an archetype registry from built-ins plus optional overrides.

## Parameters

[Section titled “Parameters”](#parameters)

### archetypes?

[Section titled “archetypes?”](#archetypes)

[`GameboardLayoutArchetypeRegistryInput`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetyperegistryinput/) | `undefined`

### options?

[Section titled “options?”](#options)

[`CreateGameboardLayoutArchetypeRegistryOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/creategameboardlayoutarchetyperegistryoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardLayoutArchetypeRegistry`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetyperegistry/)

# createGameboardLayoutFillPlacements

> **createGameboardLayoutFillPlacements**(`plan`, `options`): [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:937](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L937)

Create placement spawn options by applying layout fill rules in order.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### options

[Section titled “options”](#options)

[`GameboardLayoutFillOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfilloptions/)

## Returns

[Section titled “Returns”](#returns)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

# createGameboardLayoutPlacements

> **createGameboardLayoutPlacements**(`plan`, `options`): [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:863](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L863)

Create placement spawn options from selected layout sites.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### options

[Section titled “options”](#options)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/)

## Returns

[Section titled “Returns”](#returns)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

# inspectGameboardLayoutSites

> **inspectGameboardLayoutSites**(`plan`, `options?`): [`GameboardLayoutSiteInspection`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutsiteinspection/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:765](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L765)

Inspect candidate and rejected layout sites without creating placements.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### options?

[Section titled “options?”](#options)

[`InspectGameboardLayoutSitesOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/inspectgameboardlayoutsitesoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardLayoutSiteInspection`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutsiteinspection/)

# normalizeGameboardLayoutArchetypeRegistry

> **normalizeGameboardLayoutArchetypeRegistry**(`archetypes`): [`GameboardLayoutArchetypeRegistry`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetyperegistry/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:703](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L703)

Normalize registry input into an object keyed by archetype id.

## Parameters

[Section titled “Parameters”](#parameters)

### archetypes

[Section titled “archetypes”](#archetypes)

[`GameboardLayoutArchetypeRegistryInput`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetyperegistryinput/) | `undefined`

## Returns

[Section titled “Returns”](#returns)

[`GameboardLayoutArchetypeRegistry`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetyperegistry/)

# resolveGameboardLayoutArchetype

> **resolveGameboardLayoutArchetype**(`archetype`, `registry?`): [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:718](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L718)

Resolve an archetype id or inline archetype against a registry.

## Parameters

[Section titled “Parameters”](#parameters)

### archetype

[Section titled “archetype”](#archetype)

[`GameboardLayoutArchetypeInput`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetypeinput/) | `undefined`

### registry?

[Section titled “registry?”](#registry)

[`GameboardLayoutArchetypeRegistry`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetyperegistry/) = `GAMEBOARD_LAYOUT_ARCHETYPES`

## Returns

[Section titled “Returns”](#returns)

[`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/) | `undefined`

# resolveGameboardLayoutCriteria

> **resolveGameboardLayoutCriteria**(`archetype`, `criteria`, `registry?`): [`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:738](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L738)

Merge explicit criteria over the criteria from a resolved archetype.

## Parameters

[Section titled “Parameters”](#parameters)

### archetype

[Section titled “archetype”](#archetype)

[`GameboardLayoutArchetypeInput`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetypeinput/) | `undefined`

### criteria

[Section titled “criteria”](#criteria)

[`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/) | `undefined`

### registry?

[Section titled “registry?”](#registry)

[`GameboardLayoutArchetypeRegistry`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetyperegistry/) = `GAMEBOARD_LAYOUT_ARCHETYPES`

## Returns

[Section titled “Returns”](#returns)

[`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

# selectGameboardLayoutSites

> **selectGameboardLayoutSites**(`plan`, `options`): [`GameboardLayoutSite`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutsite/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:749](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L749)

Select deterministic valid layout sites from a generated board plan.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### options

[Section titled “options”](#options)

[`SelectGameboardLayoutSitesOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/selectgameboardlayoutsitesoptions/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardLayoutSite`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutsite/)\[]

# CreateGameboardLayoutArchetypeRegistryOptions

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:187](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L187)

Options for creating an archetype registry.

## Properties

[Section titled “Properties”](#properties)

### includeBuiltIns?

[Section titled “includeBuiltIns?”](#includebuiltins)

> `optional` **includeBuiltIns?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:189](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L189)

Include the built-in archetypes before applying overrides.

# GameboardLayoutArchetype

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:162](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L162)

Declarative placement archetype for seeded layout and fill rules.

## Properties

[Section titled “Properties”](#properties)

### criteria

[Section titled “criteria”](#criteria)

> **criteria**: [`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:172](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L172)

Site criteria applied by this archetype.

***

### id

[Section titled “id”](#id)

> **id**: [`GameboardLayoutArchetypeId`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetypeid/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:164](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L164)

Stable archetype id.

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:168](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L168)

Default placement kind.

***

### label

[Section titled “label”](#label)

> **label**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:166](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L166)

Human-readable label for diagnostics and generated docs.

***

### layer?

[Section titled “layer?”](#layer)

> `optional` **layer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:170](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L170)

Default placement layer.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:176](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L176)

Metadata merged into generated placements.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number` | `"random"`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:174](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L174)

Default rotation behavior.

# GameboardLayoutCriteria

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:195](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L195)

Rules that determine whether a tile can be used as a placement site.

## Properties

[Section titled “Properties”](#properties)

### allowOccupied?

[Section titled “allowOccupied?”](#allowoccupied)

> `optional` **allowOccupied?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:233](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L233)

Allow placement on tiles with blocking occupants.

***

### blockingPlacementKinds?

[Section titled “blockingPlacementKinds?”](#blockingplacementkinds)

> `optional` **blockingPlacementKinds?**: readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:235](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L235)

Placement kinds that should be treated as blockers.

***

### blockingPlacementLayers?

[Section titled “blockingPlacementLayers?”](#blockingplacementlayers)

> `optional` **blockingPlacementLayers?**: readonly [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:237](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L237)

Placement layers that should be treated as blockers.

***

### edgePadding?

[Section titled “edgePadding?”](#edgepadding)

> `optional` **edgePadding?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:249](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L249)

Number of outer rings excluded from placement.

***

### elevation?

[Section titled “elevation?”](#elevation)

> `optional` **elevation?**: `number` | readonly `number`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:201](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L201)

Allowed exact elevations.

***

### excludeFootprintTerrain?

[Section titled “excludeFootprintTerrain?”](#excludefootprintterrain)

> `optional` **excludeFootprintTerrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/) | readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:231](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L231)

Disallowed terrain across any footprint tile.

***

### excludeTerrain?

[Section titled “excludeTerrain?”](#excludeterrain)

> `optional` **excludeTerrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/) | readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:199](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L199)

Disallowed origin tile terrain.

***

### excludeTileTags?

[Section titled “excludeTileTags?”](#excludetiletags)

> `optional` **excludeTileTags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:209](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L209)

Tile tags that must all be absent.

***

### footprint?

[Section titled “footprint?”](#footprint)

> `optional` **footprint?**: [`GameboardLayoutFootprintInput`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutfootprintinput/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:223](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L223)

Footprint required by the placement.

***

### footprintTerrain?

[Section titled “footprintTerrain?”](#footprintterrain)

> `optional` **footprintTerrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/) | readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:229](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L229)

Allowed terrain across all footprint tiles.

***

### forbiddenAdjacentPlacementKind?

[Section titled “forbiddenAdjacentPlacementKind?”](#forbiddenadjacentplacementkind)

> `optional` **forbiddenAdjacentPlacementKind?**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/) | readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:217](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L217)

Adjacent placement kinds that must be absent.

***

### forbiddenAdjacentPlacementLayer?

[Section titled “forbiddenAdjacentPlacementLayer?”](#forbiddenadjacentplacementlayer)

> `optional` **forbiddenAdjacentPlacementLayer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/) | readonly [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:221](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L221)

Adjacent placement layers that must be absent.

***

### forbiddenAdjacentTerrain?

[Section titled “forbiddenAdjacentTerrain?”](#forbiddenadjacentterrain)

> `optional` **forbiddenAdjacentTerrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/) | readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:213](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L213)

Adjacent terrain that must be absent.

***

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:239](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L239)

Placement ids ignored during occupancy checks.

***

### maxDistance?

[Section titled “maxDistance?”](#maxdistance)

> `optional` **maxDistance?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:247](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L247)

Maximum distance from at least one `maxDistanceFrom` reference.

***

### maxDistanceFrom?

[Section titled “maxDistanceFrom?”](#maxdistancefrom)

> `optional` **maxDistanceFrom?**: readonly (`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/))\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:245](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L245)

Reference tiles that the site must stay near.

***

### maxElevation?

[Section titled “maxElevation?”](#maxelevation)

> `optional` **maxElevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:205](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L205)

Maximum origin tile elevation.

***

### maxPerTile?

[Section titled “maxPerTile?”](#maxpertile)

> `optional` **maxPerTile?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:253](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L253)

Maximum selected slots allowed on one tile.

***

### minDistance?

[Section titled “minDistance?”](#mindistance)

> `optional` **minDistance?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:243](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L243)

Minimum distance from every `minDistanceFrom` reference.

***

### minDistanceBetween?

[Section titled “minDistanceBetween?”](#mindistancebetween)

> `optional` **minDistanceBetween?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:251](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L251)

Minimum distance between selected sites from the same selection call.

***

### minDistanceFrom?

[Section titled “minDistanceFrom?”](#mindistancefrom)

> `optional` **minDistanceFrom?**: readonly (`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/))\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:241](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L241)

Reference tiles that the site must stay away from.

***

### minElevation?

[Section titled “minElevation?”](#minelevation)

> `optional` **minElevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:203](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L203)

Minimum origin tile elevation.

***

### prefer?

[Section titled “prefer?”](#prefer)

> `optional` **prefer?**: readonly [`GameboardLayoutPreference`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutpreference/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:257](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L257)

Weighted preferences used to score candidate sites.

***

### requiredAdjacentPlacementKind?

[Section titled “requiredAdjacentPlacementKind?”](#requiredadjacentplacementkind)

> `optional` **requiredAdjacentPlacementKind?**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/) | readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:215](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L215)

Adjacent placement kinds that must be present.

***

### requiredAdjacentPlacementLayer?

[Section titled “requiredAdjacentPlacementLayer?”](#requiredadjacentplacementlayer)

> `optional` **requiredAdjacentPlacementLayer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/) | readonly [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:219](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L219)

Adjacent placement layers that must be present.

***

### requiredAdjacentTerrain?

[Section titled “requiredAdjacentTerrain?”](#requiredadjacentterrain)

> `optional` **requiredAdjacentTerrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/) | readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:211](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L211)

Adjacent terrain that must be present.

***

### requireFootprintInBounds?

[Section titled “requireFootprintInBounds?”](#requirefootprintinbounds)

> `optional` **requireFootprintInBounds?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:225](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L225)

Reject sites whose footprint leaves the board.

***

### requireFootprintUnoccupied?

[Section titled “requireFootprintUnoccupied?”](#requirefootprintunoccupied)

> `optional` **requireFootprintUnoccupied?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:227](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L227)

Reject sites whose footprint has blocking occupancy.

***

### slotGroup?

[Section titled “slotGroup?”](#slotgroup)

> `optional` **slotGroup?**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:255](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L255)

Optional slot group used to share occupancy slots between compatible pieces.

***

### terrain?

[Section titled “terrain?”](#terrain)

> `optional` **terrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/) | readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:197](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L197)

Allowed origin tile terrain.

***

### tileTags?

[Section titled “tileTags?”](#tiletags)

> `optional` **tileTags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:207](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L207)

Tile tags that must all be present.

# GameboardLayoutFillAnalysis

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:531](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L531)

Analysis for a complete layout fill pass.

## Properties

[Section titled “Properties”](#properties)

### candidateCount

[Section titled “candidateCount”](#candidatecount)

> **candidateCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:539](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L539)

Sum of candidate counts across rules.

***

### errorCount

[Section titled “errorCount”](#errorcount)

> **errorCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:543](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L543)

Total error count.

***

### errors

[Section titled “errors”](#errors)

> **errors**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:547](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L547)

All errors prefixed by rule id.

***

### placementCount

[Section titled “placementCount”](#placementcount)

> **placementCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:537](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L537)

Number of placements selected by all rules.

***

### ruleCount

[Section titled “ruleCount”](#rulecount)

> **ruleCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:535](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L535)

Number of rules analyzed.

***

### rules

[Section titled “rules”](#rules)

> **rules**: readonly [`GameboardLayoutFillRuleAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillruleanalysis/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:549](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L549)

Per-rule analysis.

***

### seed

[Section titled “seed”](#seed)

> **seed**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:533](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L533)

Seed used by the fill pass.

***

### warningCount

[Section titled “warningCount”](#warningcount)

> **warningCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:541](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L541)

Total warning count.

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:545](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L545)

All warnings prefixed by rule id.

# GameboardLayoutFillOptions

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:483](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L483)

Options for applying several layout fill rules in sequence.

## Properties

[Section titled “Properties”](#properties)

### rules

[Section titled “rules”](#rules)

> **rules**: readonly [`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:487](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L487)

Ordered fill rules. Later rules see earlier generated placements.

***

### seed?

[Section titled “seed?”](#seed)

> `optional` **seed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:485](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L485)

Shared seed for deterministic fill rules.

# GameboardLayoutFillRule

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:460](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L460)

Rule for seeded layout fill across one or more assets.

## Extends

[Section titled “Extends”](#extends)

* `Omit`<[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/), `"assetId"` | `"count"` | `"seed"` | `"idPrefix"`>

## Properties

[Section titled “Properties”](#properties)

### archetype?

[Section titled “archetype?”](#archetype)

> `optional` **archetype?**: [`GameboardLayoutArchetypeInput`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetypeinput/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:430](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L430)

Archetype id or inline archetype.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/).[`archetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/#archetype)

***

### archetypes?

[Section titled “archetypes?”](#archetypes)

> `optional` **archetypes?**: `Readonly`<`Record`<`string`, [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)>>

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:432](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L432)

Registry used to resolve `archetype`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/).[`archetypes`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/#archetypes)

***

### assetId?

[Section titled “assetId?”](#assetid)

> `optional` **assetId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:465](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L465)

Single asset id used by the rule.

***

### assets?

[Section titled “assets?”](#assets)

> `optional` **assets?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:467](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L467)

Asset ids cycled deterministically across selected sites.

***

### count?

[Section titled “count?”](#count)

> `optional` **count?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:469](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L469)

Explicit placement count.

***

### criteria?

[Section titled “criteria?”](#criteria)

> `optional` **criteria?**: [`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:446](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L446)

Criteria merged over archetype defaults.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/).[`criteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/#criteria)

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:310](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L310)

Extra vertical offset above the tile elevation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`elevationOffset`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#elevationoffset)

***

### fill?

[Section titled “fill?”](#fill)

> `optional` **fill?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:471](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L471)

Fraction of candidate sites to fill.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:463](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L463)

Stable rule id used in diagnostics and generated ids.

***

### idPrefix?

[Section titled “idPrefix?”](#idprefix)

> `optional` **idPrefix?**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:477](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L477)

Prefix used when assigning deterministic placement ids.

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:434](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L434)

Placement kind override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/).[`kind`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/#kind)

***

### layer?

[Section titled “layer?”](#layer)

> `optional` **layer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:436](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L436)

Placement layer override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/).[`layer`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/#layer)

***

### maxCount?

[Section titled “maxCount?”](#maxcount)

> `optional` **maxCount?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:475](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L475)

Maximum placement count after fill/count calculation.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:324](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L324)

Serializable placement metadata for rules, ECS interop, and render hints.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`metadata`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#metadata)

***

### minCount?

[Section titled “minCount?”](#mincount)

> `optional` **minCount?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:473](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L473)

Minimum placement count after fill/count calculation.

***

### occupancyGuard?

[Section titled “occupancyGuard?”](#occupancyguard)

> `optional` **occupancyGuard?**: [`GameboardPlacementOccupancyGuard`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementoccupancyguard/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:326](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L326)

Optional occupancy validation before spawning.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`occupancyGuard`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#occupancyguard)

***

### onDiagnostics?

[Section titled “onDiagnostics?”](#ondiagnostics)

> `optional` **onDiagnostics?**: (`diagnostics`) => `void`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:454](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L454)

Called when the selected site count is less than the requested `count` (including zero). Reports the resolved criteria and a rejection histogram so an empty result is distinguishable from “board is full”. Never called when `selectedCount >= requestedCount`. No-op by default — absent option means zero behavior change.

#### Parameters

[Section titled “Parameters”](#parameters)

##### diagnostics

[Section titled “diagnostics”](#diagnostics)

[`GameboardLayoutPlacementDiagnostics`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementdiagnostics/)

#### Returns

[Section titled “Returns”](#returns)

`void`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

`Omit.onDiagnostics`

***

### order?

[Section titled “order?”](#order)

> `optional` **order?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:318](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L318)

Stable sort order used by renderers and snapshots.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`order`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#order)

***

### positionOffset?

[Section titled “positionOffset?”](#positionoffset)

> `optional` **positionOffset?**: [`GameboardPlacementPositionOffset`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementpositionoffset/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:312](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L312)

Local world-space offset after tile/elevation anchoring.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`positionOffset`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#positionoffset)

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:322](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L322)

Whether the placement depends on local-only EXTRA assets.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`requiresExtra`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#requiresextra)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number` | `"random"`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:444](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L444)

Rotation steps or deterministic random rotation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

`Omit.rotationSteps`

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:316](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L316)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#scale)

***

### stackIndex?

[Section titled “stackIndex?”](#stackindex)

> `optional` **stackIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:320](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L320)

Optional stack index for layered terrain and vertical props.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-14)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`stackIndex`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#stackindex)

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:308](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L308)

Texture set override. Defaults to the origin tile texture set.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-15)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`textureSet`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#textureset)

# GameboardLayoutFillRuleAnalysis

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:493](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L493)

Analysis for one layout fill rule.

## Properties

[Section titled “Properties”](#properties)

### archetypeId?

[Section titled “archetypeId?”](#archetypeid)

> `optional` **archetypeId?**: [`GameboardLayoutArchetypeId`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetypeid/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:499](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L499)

Resolved archetype id.

***

### assetIds

[Section titled “assetIds”](#assetids)

> **assetIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:505](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L505)

Configured asset ids.

***

### candidateCount

[Section titled “candidateCount”](#candidatecount)

> **candidateCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:509](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L509)

Candidate site count before target count limits.

***

### errors

[Section titled “errors”](#errors)

> **errors**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:525](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L525)

Fatal diagnostics for the rule.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:495](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L495)

Stable rule id.

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:501](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L501)

Resolved placement kind.

***

### layer?

[Section titled “layer?”](#layer)

> `optional` **layer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:503](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L503)

Resolved placement layer.

***

### rejectedSiteCount

[Section titled “rejectedSiteCount”](#rejectedsitecount)

> **rejectedSiteCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:511](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L511)

Rejected site count.

***

### rejectionCounts

[Section titled “rejectionCounts”](#rejectioncounts)

> **rejectionCounts**: `Readonly`<`Partial`<`Record`<[`GameboardLayoutSiteRejectionCode`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutsiterejectioncode/), `number`>>>

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:513](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L513)

Rejection counts grouped by code.

***

### requestedCount

[Section titled “requestedCount”](#requestedcount)

> **requestedCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:515](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L515)

Count requested by `count`, `fill`, and min/max settings.

***

### ruleIndex

[Section titled “ruleIndex”](#ruleindex)

> **ruleIndex**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:497](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L497)

Rule index in the fill options.

***

### selectedAssetIds

[Section titled “selectedAssetIds”](#selectedassetids)

> **selectedAssetIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:507](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L507)

Asset ids selected for generated placements.

***

### selectedCount

[Section titled “selectedCount”](#selectedcount)

> **selectedCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:519](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L519)

Number of placements selected by the rule.

***

### selectedTileKeys

[Section titled “selectedTileKeys”](#selectedtilekeys)

> **selectedTileKeys**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:521](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L521)

Tile keys selected by the rule.

***

### targetCount

[Section titled “targetCount”](#targetcount)

> **targetCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:517](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L517)

Final target count after candidate limits and diagnostics.

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:523](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L523)

Non-fatal diagnostics for the rule.

# GameboardLayoutPlacementDiagnostics

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:400](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L400)

Diagnostics reported when a single-placement layout call finds fewer candidate sites than requested (including zero). Surfaces the fully resolved criteria (post archetype merge) so archetype-inherited fields the caller never set — e.g. the `landmark` archetype’s `edgePadding: 1` — are visible instead of silently emptying the candidate set.

## Properties

[Section titled “Properties”](#properties)

### archetypeId?

[Section titled “archetypeId?”](#archetypeid)

> `optional` **archetypeId?**: [`GameboardLayoutArchetypeId`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetypeid/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:419](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L419)

Archetype id used to resolve defaults, if any.

***

### candidateCount

[Section titled “candidateCount”](#candidatecount)

> **candidateCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:406](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L406)

Number of candidate sites that satisfied criteria, before `count` limits.

***

### rejectedCount

[Section titled “rejectedCount”](#rejectedcount)

> **rejectedCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:408](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L408)

Number of rejected sites.

***

### rejectionCounts

[Section titled “rejectionCounts”](#rejectioncounts)

> **rejectionCounts**: `Readonly`<`Partial`<`Record`<[`GameboardLayoutSiteRejectionCode`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutsiterejectioncode/), `number`>>>

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:410](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L410)

Rejection counts grouped by code — names which filter emptied the set.

***

### requestedCount

[Section titled “requestedCount”](#requestedcount)

> **requestedCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:402](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L402)

Number of placements requested via `count`.

***

### resolvedCriteria

[Section titled “resolvedCriteria”](#resolvedcriteria)

> **resolvedCriteria**: [`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:417](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L417)

Fully resolved criteria used for site selection, i.e. archetype defaults merged with caller-supplied overrides via `mergeLayoutCriteria`. Fields present here but absent from the caller’s `criteria` were inherited from the archetype.

***

### seed

[Section titled “seed”](#seed)

> **seed**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:421](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L421)

Seed used for deterministic tie-breaking.

***

### selectedCount

[Section titled “selectedCount”](#selectedcount)

> **selectedCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:404](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L404)

Number of placements actually selected.

# GameboardLayoutPlacementOptions

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:427](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L427)

Options for creating placement specs from selected layout sites.

## Extends

[Section titled “Extends”](#extends)

* `Omit`<[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/), `"at"` | `"id"` | `"kind"` | `"layer"` | `"rotationSteps"`>

## Properties

[Section titled “Properties”](#properties)

### archetype?

[Section titled “archetype?”](#archetype)

> `optional` **archetype?**: [`GameboardLayoutArchetypeInput`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetypeinput/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:430](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L430)

Archetype id or inline archetype.

***

### archetypes?

[Section titled “archetypes?”](#archetypes)

> `optional` **archetypes?**: `Readonly`<`Record`<`string`, [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)>>

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:432](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L432)

Registry used to resolve `archetype`.

***

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:302](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L302)

Manifest or external registry asset id to render.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`assetId`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#assetid)

***

### count?

[Section titled “count?”](#count)

> `optional` **count?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:438](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L438)

Number of placements to create.

***

### criteria?

[Section titled “criteria?”](#criteria)

> `optional` **criteria?**: [`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:446](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L446)

Criteria merged over archetype defaults.

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:310](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L310)

Extra vertical offset above the tile elevation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`elevationOffset`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#elevationoffset)

***

### idPrefix?

[Section titled “idPrefix?”](#idprefix)

> `optional` **idPrefix?**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:442](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L442)

Prefix used when assigning deterministic placement ids.

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:434](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L434)

Placement kind override.

***

### layer?

[Section titled “layer?”](#layer)

> `optional` **layer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:436](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L436)

Placement layer override.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:324](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L324)

Serializable placement metadata for rules, ECS interop, and render hints.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`metadata`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#metadata)

***

### occupancyGuard?

[Section titled “occupancyGuard?”](#occupancyguard)

> `optional` **occupancyGuard?**: [`GameboardPlacementOccupancyGuard`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementoccupancyguard/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:326](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L326)

Optional occupancy validation before spawning.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`occupancyGuard`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#occupancyguard)

***

### onDiagnostics?

[Section titled “onDiagnostics?”](#ondiagnostics)

> `optional` **onDiagnostics?**: (`diagnostics`) => `void`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:454](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L454)

Called when the selected site count is less than the requested `count` (including zero). Reports the resolved criteria and a rejection histogram so an empty result is distinguishable from “board is full”. Never called when `selectedCount >= requestedCount`. No-op by default — absent option means zero behavior change.

#### Parameters

[Section titled “Parameters”](#parameters)

##### diagnostics

[Section titled “diagnostics”](#diagnostics)

[`GameboardLayoutPlacementDiagnostics`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementdiagnostics/)

#### Returns

[Section titled “Returns”](#returns)

`void`

***

### order?

[Section titled “order?”](#order)

> `optional` **order?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:318](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L318)

Stable sort order used by renderers and snapshots.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`order`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#order)

***

### positionOffset?

[Section titled “positionOffset?”](#positionoffset)

> `optional` **positionOffset?**: [`GameboardPlacementPositionOffset`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementpositionoffset/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:312](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L312)

Local world-space offset after tile/elevation anchoring.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`positionOffset`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#positionoffset)

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:322](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L322)

Whether the placement depends on local-only EXTRA assets.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`requiresExtra`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#requiresextra)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number` | `"random"`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:444](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L444)

Rotation steps or deterministic random rotation.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:316](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L316)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#scale)

***

### seed?

[Section titled “seed?”](#seed)

> `optional` **seed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:440](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L440)

Seed used for site selection and random rotation.

***

### stackIndex?

[Section titled “stackIndex?”](#stackindex)

> `optional` **stackIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:320](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L320)

Optional stack index for layered terrain and vertical props.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`stackIndex`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#stackindex)

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:308](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L308)

Texture set override. Defaults to the origin tile texture set.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`textureSet`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#textureset)

# GameboardLayoutRejectedSite

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:340](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L340)

Rejected tile with full diagnostics.

## Properties

[Section titled “Properties”](#properties)

### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:346](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L346)

Rejected tile coordinates.

***

### footprintKeys

[Section titled “footprintKeys”](#footprintkeys)

> **footprintKeys**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:352](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L352)

Tile keys covered by the requested footprint.

***

### footprintPlacements

[Section titled “footprintPlacements”](#footprintplacements)

> **footprintPlacements**: readonly [`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:354](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L354)

Placements on any footprint tile.

***

### key

[Section titled “key”](#key)

> **key**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:344](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L344)

Rejected tile key.

***

### occupied

[Section titled “occupied”](#occupied)

> **occupied**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:348](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L348)

Whether blocking occupancy contributed to the rejection.

***

### placements

[Section titled “placements”](#placements)

> **placements**: readonly [`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:350](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L350)

Placements on the rejected origin tile.

***

### rejections

[Section titled “rejections”](#rejections)

> **rejections**: readonly [`GameboardLayoutSiteRejection`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutsiterejection/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:356](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L356)

Rejection diagnostics.

***

### tile

[Section titled “tile”](#tile)

> **tile**: [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:342](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L342)

Tile rejected for placement.

# GameboardLayoutSite

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:275](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L275)

Candidate or selected placement site.

## Properties

[Section titled “Properties”](#properties)

### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:281](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L281)

Tile coordinates selected for placement.

***

### footprintKeys

[Section titled “footprintKeys”](#footprintkeys)

> **footprintKeys**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:297](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L297)

Tile keys covered by the placement footprint.

***

### footprintPlacements

[Section titled “footprintPlacements”](#footprintplacements)

> **footprintPlacements**: readonly [`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:299](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L299)

Placements on any footprint tile.

***

### footprintTiles

[Section titled “footprintTiles”](#footprinttiles)

> **footprintTiles**: readonly [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:295](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L295)

Tiles covered by the placement footprint.

***

### key

[Section titled “key”](#key)

> **key**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:279](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L279)

Tile key selected for placement.

***

### occupied

[Section titled “occupied”](#occupied)

> **occupied**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:291](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L291)

Whether the tile has blocking occupants.

***

### placements

[Section titled “placements”](#placements)

> **placements**: readonly [`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:293](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L293)

Placements on the origin tile.

***

### position

[Section titled “position”](#position)

> **position**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:283](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L283)

World position at the tile/elevation anchor.

***

### reasons

[Section titled “reasons”](#reasons)

> **reasons**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:301](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L301)

Score reasons used for diagnostics.

***

### score

[Section titled “score”](#score)

> **score**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:285](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L285)

Weighted score used to sort candidates.

***

### slotIndex

[Section titled “slotIndex”](#slotindex)

> **slotIndex**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:287](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L287)

Slot index chosen on the tile.

***

### tile

[Section titled “tile”](#tile)

> **tile**: [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:277](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L277)

Tile selected for placement.

***

### usedSlotIndexes

[Section titled “usedSlotIndexes”](#usedslotindexes)

> **usedSlotIndexes**: readonly `number`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:289](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L289)

Slot indexes already occupied before selection.

# GameboardLayoutSiteInspection

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:374](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L374)

Candidate, selection, and rejection report for layout criteria.

## Properties

[Section titled “Properties”](#properties)

### candidateCount

[Section titled “candidateCount”](#candidatecount)

> **candidateCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:380](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L380)

Number of candidate sites that satisfied criteria.

***

### candidates

[Section titled “candidates”](#candidates)

> **candidates**: readonly [`GameboardLayoutSite`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutsite/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:388](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L388)

Candidate sites sorted by score.

***

### rejected

[Section titled “rejected”](#rejected)

> **rejected**: readonly [`GameboardLayoutRejectedSite`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutrejectedsite/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:390](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L390)

Rejected sites with diagnostics.

***

### rejectedCount

[Section titled “rejectedCount”](#rejectedcount)

> **rejectedCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:382](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L382)

Number of rejected sites.

***

### rejectionCounts

[Section titled “rejectionCounts”](#rejectioncounts)

> **rejectionCounts**: `Readonly`<`Partial`<`Record`<[`GameboardLayoutSiteRejectionCode`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutsiterejectioncode/), `number`>>>

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:384](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L384)

Rejection counts grouped by code.

***

### seed

[Section titled “seed”](#seed)

> **seed**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:376](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L376)

Seed used for deterministic tie-breaking.

***

### selected

[Section titled “selected”](#selected)

> **selected**: readonly [`GameboardLayoutSite`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutsite/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:386](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L386)

Selected sites.

***

### selectedCount

[Section titled “selectedCount”](#selectedcount)

> **selectedCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:378](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L378)

Number of selected sites returned.

# GameboardLayoutSiteRejection

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:330](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L330)

Diagnostic for one rejected layout site.

## Properties

[Section titled “Properties”](#properties)

### code

[Section titled “code”](#code)

> **code**: [`GameboardLayoutSiteRejectionCode`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutsiterejectioncode/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:332](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L332)

Machine-readable rejection code.

***

### message

[Section titled “message”](#message)

> **message**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:334](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L334)

Human-readable rejection message.

# InspectGameboardLayoutSitesOptions

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:362](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L362)

Options for inspecting layout candidates and rejections.

## Properties

[Section titled “Properties”](#properties)

### count?

[Section titled “count?”](#count)

> `optional` **count?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:364](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L364)

Optional number of selected sites to include.

***

### criteria?

[Section titled “criteria?”](#criteria)

> `optional` **criteria?**: [`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:368](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L368)

Site criteria.

***

### seed?

[Section titled “seed?”](#seed)

> `optional` **seed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:366](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L366)

Seed used to break score ties deterministically.

# ResolvedGameboardLayoutFootprint

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:146](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L146)

Normalized footprint definition.

## Properties

[Section titled “Properties”](#properties)

### edges?

[Section titled “edges?”](#edges)

> `optional` **edges?**: readonly [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:152](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L152)

Neighbor edges used by adjacent footprints.

***

### includeCenter

[Section titled “includeCenter”](#includecenter)

> **includeCenter**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:156](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L156)

Whether the origin tile is part of the footprint.

***

### kind

[Section titled “kind”](#kind)

> **kind**: `"single"` | `"adjacent"` | `"radius"` | `"custom"`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:148](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L148)

Footprint mode.

***

### offsets?

[Section titled “offsets?”](#offsets)

> `optional` **offsets?**: readonly [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:154](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L154)

Custom axial offsets included in the footprint.

***

### radius

[Section titled “radius”](#radius)

> **radius**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:150](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L150)

Radius used by radius footprints.

# SelectGameboardLayoutSitesOptions

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:263](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L263)

Options for selecting valid layout sites from a plan.

## Properties

[Section titled “Properties”](#properties)

### count

[Section titled “count”](#count)

> **count**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:265](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L265)

Number of sites to select.

***

### criteria?

[Section titled “criteria?”](#criteria)

> `optional` **criteria?**: [`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:269](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L269)

Site criteria.

***

### seed?

[Section titled “seed?”](#seed)

> `optional` **seed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:267](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L267)

Seed used to break score ties deterministically.

# BuiltInGameboardLayoutArchetypeId

> **BuiltInGameboardLayoutArchetypeId** = `"surface"` | `"building"` | `"harbor"` | `"unit"` | `"prop"` | `"tree"` | `"scatter"` | `"landmark"`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:100](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L100)

Built-in archetypes for common board pieces such as structures, units, trees, scatter props, and harbors.

# GameboardLayoutArchetypeId

> **GameboardLayoutArchetypeId** = [`BuiltInGameboardLayoutArchetypeId`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/builtingameboardlayoutarchetypeid/) | `string` & `object`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:112](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L112)

Layout archetype id accepted by the registry.

# GameboardLayoutArchetypeInput

> **GameboardLayoutArchetypeInput** = [`GameboardLayoutArchetypeId`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetypeid/) | [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:116](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L116)

Archetype reference accepted by placement helpers.

# GameboardLayoutArchetypeRegistry

> **GameboardLayoutArchetypeRegistry** = `Readonly`<`Record`<`string`, [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)>>

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:182](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L182)

Archetype registry keyed by archetype id.

# GameboardLayoutArchetypeRegistryInput

> **GameboardLayoutArchetypeRegistryInput** = [`GameboardLayoutArchetypeRegistry`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetyperegistry/) | readonly [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:120](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L120)

Input accepted when creating or overriding an archetype registry.

# GameboardLayoutFootprintInput

> **GameboardLayoutFootprintInput** = `"single"` | `"adjacent"` | `number` | { `edges?`: readonly [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)\[]; `includeCenter?`: `boolean`; `kind`: `"single"` | `"adjacent"` | `"radius"` | `"custom"`; `offsets?`: readonly [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]; `radius?`: `number`; }

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L126)

Footprint definition used for multi-tile placement and occupancy criteria.

## Union Members

[Section titled “Union Members”](#union-members)

`"single"`

***

`"adjacent"`

***

`number`

***

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `edges?`: readonly [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)\[]; `includeCenter?`: `boolean`; `kind`: `"single"` | `"adjacent"` | `"radius"` | `"custom"`; `offsets?`: readonly [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]; `radius?`: `number`; }

#### edges?

[Section titled “edges?”](#edges)

> `optional` **edges?**: readonly [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)\[]

Neighbor edges included by adjacent footprints.

#### includeCenter?

[Section titled “includeCenter?”](#includecenter)

> `optional` **includeCenter?**: `boolean`

Whether the origin tile is part of the footprint.

#### kind

[Section titled “kind”](#kind)

> **kind**: `"single"` | `"adjacent"` | `"radius"` | `"custom"`

Footprint mode.

#### offsets?

[Section titled “offsets?”](#offsets)

> `optional` **offsets?**: readonly [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Custom axial offsets included in the footprint.

#### radius?

[Section titled “radius?”](#radius)

> `optional` **radius?**: `number`

Radius used by radius footprints.

# GameboardLayoutPreference

> **GameboardLayoutPreference** = { `kind`: `"center"`; `weight?`: `number`; } | { `kind`: `"edge"`; `weight?`: `number`; } | { `kind`: `"near-terrain"`; `radius?`: `number`; `terrain`: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/) | readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]; `weight?`: `number`; } | { `kind`: `"far-from-terrain"`; `radius?`: `number`; `terrain`: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/) | readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]; `weight?`: `number`; } | { `kind`: `"near-placement-kind"`; `placementKind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/) | readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]; `radius?`: `number`; `weight?`: `number`; } | { `kind`: `"far-from-placement-kind"`; `placementKind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/) | readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]; `radius?`: `number`; `weight?`: `number`; } | { `kind`: `"high-elevation"`; `weight?`: `number`; } | { `kind`: `"low-elevation"`; `weight?`: `number`; }

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:30](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L30)

Weighted placement preference used to score otherwise valid layout sites.

## Union Members

[Section titled “Union Members”](#union-members)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `kind`: `"center"`; `weight?`: `number`; }

#### kind

[Section titled “kind”](#kind)

> **kind**: `"center"`

Preference discriminator for tiles near the board center.

#### weight?

[Section titled “weight?”](#weight)

> `optional` **weight?**: `number`

Score multiplier for this preference.

***

### Type Literal

[Section titled “Type Literal”](#type-literal-1)

{ `kind`: `"edge"`; `weight?`: `number`; }

#### kind

[Section titled “kind”](#kind-1)

> **kind**: `"edge"`

Preference discriminator for tiles near the board edge.

#### weight?

[Section titled “weight?”](#weight-1)

> `optional` **weight?**: `number`

Score multiplier for this preference.

***

### Type Literal

[Section titled “Type Literal”](#type-literal-2)

{ `kind`: `"near-terrain"`; `radius?`: `number`; `terrain`: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/) | readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]; `weight?`: `number`; }

#### kind

[Section titled “kind”](#kind-2)

> **kind**: `"near-terrain"`

Preference discriminator for tiles near matching terrain.

#### radius?

[Section titled “radius?”](#radius)

> `optional` **radius?**: `number`

Search radius for nearby terrain.

#### terrain

[Section titled “terrain”](#terrain)

> **terrain**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/) | readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]

Terrain values considered by this preference.

#### weight?

[Section titled “weight?”](#weight-2)

> `optional` **weight?**: `number`

Score multiplier for this preference.

***

### Type Literal

[Section titled “Type Literal”](#type-literal-3)

{ `kind`: `"far-from-terrain"`; `radius?`: `number`; `terrain`: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/) | readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]; `weight?`: `number`; }

#### kind

[Section titled “kind”](#kind-3)

> **kind**: `"far-from-terrain"`

Preference discriminator for tiles away from matching terrain.

#### radius?

[Section titled “radius?”](#radius-1)

> `optional` **radius?**: `number`

Search radius for nearby terrain.

#### terrain

[Section titled “terrain”](#terrain-1)

> **terrain**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/) | readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]

Terrain values considered by this preference.

#### weight?

[Section titled “weight?”](#weight-3)

> `optional` **weight?**: `number`

Score multiplier for this preference.

***

### Type Literal

[Section titled “Type Literal”](#type-literal-4)

{ `kind`: `"near-placement-kind"`; `placementKind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/) | readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]; `radius?`: `number`; `weight?`: `number`; }

#### kind

[Section titled “kind”](#kind-4)

> **kind**: `"near-placement-kind"`

Preference discriminator for tiles near matching placement kinds.

#### placementKind

[Section titled “placementKind”](#placementkind)

> **placementKind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/) | readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Placement kinds considered by this preference.

#### radius?

[Section titled “radius?”](#radius-2)

> `optional` **radius?**: `number`

Search radius for nearby placements.

#### weight?

[Section titled “weight?”](#weight-4)

> `optional` **weight?**: `number`

Score multiplier for this preference.

***

### Type Literal

[Section titled “Type Literal”](#type-literal-5)

{ `kind`: `"far-from-placement-kind"`; `placementKind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/) | readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]; `radius?`: `number`; `weight?`: `number`; }

#### kind

[Section titled “kind”](#kind-5)

> **kind**: `"far-from-placement-kind"`

Preference discriminator for tiles away from matching placement kinds.

#### placementKind

[Section titled “placementKind”](#placementkind-1)

> **placementKind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/) | readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Placement kinds considered by this preference.

#### radius?

[Section titled “radius?”](#radius-3)

> `optional` **radius?**: `number`

Search radius for nearby placements.

#### weight?

[Section titled “weight?”](#weight-5)

> `optional` **weight?**: `number`

Score multiplier for this preference.

***

### Type Literal

[Section titled “Type Literal”](#type-literal-6)

{ `kind`: `"high-elevation"`; `weight?`: `number`; }

#### kind

[Section titled “kind”](#kind-6)

> **kind**: `"high-elevation"`

Preference discriminator for higher elevation tiles.

#### weight?

[Section titled “weight?”](#weight-6)

> `optional` **weight?**: `number`

Score multiplier for this preference.

***

### Type Literal

[Section titled “Type Literal”](#type-literal-7)

{ `kind`: `"low-elevation"`; `weight?`: `number`; }

#### kind

[Section titled “kind”](#kind-7)

> **kind**: `"low-elevation"`

Preference discriminator for lower elevation tiles.

#### weight?

[Section titled “weight?”](#weight-7)

> `optional` **weight?**: `number`

Score multiplier for this preference.

# GameboardLayoutSiteRejectionCode

> **GameboardLayoutSiteRejectionCode** = `"footprint-out-of-bounds"` | `"footprint-terrain"` | `"terrain"` | `"excluded-terrain"` | `"elevation"` | `"missing-required-tags"` | `"excluded-tags"` | `"occupied"` | `"edge-padding"` | `"missing-adjacent-terrain"` | `"forbidden-adjacent-terrain"` | `"missing-adjacent-placement-kind"` | `"forbidden-adjacent-placement-kind"` | `"missing-adjacent-placement-layer"` | `"forbidden-adjacent-placement-layer"` | `"min-distance"` | `"max-distance"` | `"slots-full"`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:307](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L307)

Rejection codes emitted when a tile cannot satisfy layout criteria.

# GAMEBOARD_LAYOUT_ARCHETYPES

> `const` **GAMEBOARD\_LAYOUT\_ARCHETYPES**: [`GameboardLayoutArchetypeRegistry`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetyperegistry/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:562](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L562)

Built-in layout archetypes for common surface, structure, harbor, unit, prop, scatter, and landmark placement behavior.

# projectWorldToGameboardPlan

> **projectWorldToGameboardPlan**(`world`, `options?`): [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/projection.ts:49](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/projection.ts#L49)

Projects a Koota gameboard world into a serializable gameboard plan with render placements.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### options?

[Section titled “options?”](#options)

[`ProjectWorldOptions`](/declarative-hex-worlds/reference/coordinates/projection/interfaces/projectworldoptions/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

# readDecomposedTileSpecs

> **readDecomposedTileSpecs**(`world`): [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/projection.ts:73](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/projection.ts#L73)

Reads decomposed tile components from a Koota world as plan tile specs.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

## Returns

[Section titled “Returns”](#returns)

[`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)\[]

# readValidationGameboardPlanFromWorld

> **readValidationGameboardPlanFromWorld**(`world`): [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/projection.ts:104](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/projection.ts#L104)

Reads a lightweight validation plan from a Koota world without rebuilding render overlays.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

# ProjectWorldOptions

Defined in: [packages/declarative-hex-worlds/src/coordinates/projection.ts:36](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/projection.ts#L36)

Options for projecting a world into a plan.

## Properties

[Section titled “Properties”](#properties)

### geometry?

[Section titled “geometry?”](#geometry)

> `optional` **geometry?**: [`HexGeometry`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/hexgeometry/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/projection.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/projection.ts#L45)

Hex world geometry used to place tiles (their `position`). Defaults to `DEFAULT_HEX_GEOMETRY`. Override for a board whose row spacing differs from a regular hex — e.g. a TILESET board whose cells bake a vertically-foreshortened (isometric) hex: its rows must be packed at `height/2`, i.e. `depth = (4/3)·(width·cellHeight/cellWidth)/2`, so full-cell quads interlock seamlessly instead of spreading \~3× too far apart in Z.

# GameboardCliError

Defined in: [packages/declarative-hex-worlds/src/errors/index.ts:63](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/errors/index.ts#L63)

Thrown when the CLI hits invalid flags / missing inputs / illegal output paths.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/)

## Constructors

[Section titled “Constructors”](#constructors)

### Constructor

[Section titled “Constructor”](#constructor)

> **new GameboardCliError**(`message`, `options?`): `GameboardCliError`

Defined in: [packages/declarative-hex-worlds/src/errors/index.ts:41](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/errors/index.ts#L41)

#### Parameters

[Section titled “Parameters”](#parameters)

##### message

[Section titled “message”](#message)

`string`

##### options?

[Section titled “options?”](#options)

###### cause?

[Section titled “cause?”](#cause)

`unknown`

#### Returns

[Section titled “Returns”](#returns)

`GameboardCliError`

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`constructor`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#constructor)

## Properties

[Section titled “Properties”](#properties)

### cause?

[Section titled “cause?”](#cause-1)

> `optional` **cause?**: `unknown`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:24

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`cause`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#cause)

***

### message

[Section titled “message”](#message-1)

> **message**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1075

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`message`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#message)

***

### name

[Section titled “name”](#name)

> **name**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1074

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`name`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#name)

***

### stack?

[Section titled “stack?”](#stack)

> `optional` **stack?**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1076

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`stack`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#stack)

***

### stackTraceLimit

[Section titled “stackTraceLimit”](#stacktracelimit)

> `static` **stackTraceLimit**: `number`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:67

The `Error.stackTraceLimit` property specifies the number of stack frames collected by a stack trace (whether generated by `new Error().stack` or `Error.captureStackTrace(obj)`).

The default value is `10` but may be set to any valid JavaScript number. Changes will affect any stack trace captured *after* the value has been changed.

If set to a non-number value, or set to a negative number, stack traces will not capture any frames.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`stackTraceLimit`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#stacktracelimit)

## Methods

[Section titled “Methods”](#methods)

### captureStackTrace()

[Section titled “captureStackTrace()”](#capturestacktrace)

> `static` **captureStackTrace**(`targetObject`, `constructorOpt?`): `void`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:51

Creates a `.stack` property on `targetObject`, which when accessed returns a string representing the location in the code at which `Error.captureStackTrace()` was called.

```js
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack;  // Similar to `new Error().stack`
```

The first line of the trace will be prefixed with `${myObject.name}: ${myObject.message}`.

The optional `constructorOpt` argument accepts a function. If given, all frames above `constructorOpt`, including `constructorOpt`, will be omitted from the generated stack trace.

The `constructorOpt` argument is useful for hiding implementation details of error generation from the user. For instance:

```js
function a() {
  b();
}


function b() {
  c();
}


function c() {
  // Create an error without stack trace to avoid calculating the stack trace twice.
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  const error = new Error();
  Error.stackTraceLimit = stackTraceLimit;


  // Capture the stack trace above function b
  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
  throw error;
}


a();
```

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### targetObject

[Section titled “targetObject”](#targetobject)

`object`

##### constructorOpt?

[Section titled “constructorOpt?”](#constructoropt)

`Function`

#### Returns

[Section titled “Returns”](#returns-1)

`void`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`captureStackTrace`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#capturestacktrace)

***

### prepareStackTrace()

[Section titled “prepareStackTrace()”](#preparestacktrace)

> `static` **prepareStackTrace**(`err`, `stackTraces`): `any`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:55

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### err

[Section titled “err”](#err)

`Error`

##### stackTraces

[Section titled “stackTraces”](#stacktraces)

`CallSite`\[]

#### Returns

[Section titled “Returns”](#returns-2)

`any`

#### See

[Section titled “See”](#see)

<https://v8.dev/docs/stack-trace-api#customizing-stack-traces>

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`prepareStackTrace`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#preparestacktrace)

# GameboardError

Defined in: [packages/declarative-hex-worlds/src/errors/index.ts:40](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/errors/index.ts#L40)

Base for every error this library throws.

Consumers can branch on `instanceof GameboardError` to handle anything library-originated separately from genuine bugs (`TypeError`, `ReferenceError`, etc.).

## Extends

[Section titled “Extends”](#extends)

* `Error`

## Extended by

[Section titled “Extended by”](#extended-by)

* [`GameboardValidationError`](/declarative-hex-worlds/reference/errors/classes/gameboardvalidationerror/)
* [`GameboardManifestError`](/declarative-hex-worlds/reference/errors/classes/gameboardmanifesterror/)
* [`GameboardScenarioError`](/declarative-hex-worlds/reference/errors/classes/gameboardscenarioerror/)
* [`GameboardRuntimeError`](/declarative-hex-worlds/reference/errors/classes/gameboardruntimeerror/)
* [`GameboardCliError`](/declarative-hex-worlds/reference/errors/classes/gameboardclierror/)
* [`GameboardIoError`](/declarative-hex-worlds/reference/errors/classes/gameboardioerror/)

## Constructors

[Section titled “Constructors”](#constructors)

### Constructor

[Section titled “Constructor”](#constructor)

> **new GameboardError**(`message`, `options?`): `GameboardError`

Defined in: [packages/declarative-hex-worlds/src/errors/index.ts:41](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/errors/index.ts#L41)

#### Parameters

[Section titled “Parameters”](#parameters)

##### message

[Section titled “message”](#message)

`string`

##### options?

[Section titled “options?”](#options)

###### cause?

[Section titled “cause?”](#cause)

`unknown`

#### Returns

[Section titled “Returns”](#returns)

`GameboardError`

#### Overrides

[Section titled “Overrides”](#overrides)

`Error.constructor`

## Properties

[Section titled “Properties”](#properties)

### cause?

[Section titled “cause?”](#cause-1)

> `optional` **cause?**: `unknown`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:24

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

`Error.cause`

***

### message

[Section titled “message”](#message-1)

> **message**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1075

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

`Error.message`

***

### name

[Section titled “name”](#name)

> **name**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1074

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

`Error.name`

***

### stack?

[Section titled “stack?”](#stack)

> `optional` **stack?**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1076

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

`Error.stack`

***

### stackTraceLimit

[Section titled “stackTraceLimit”](#stacktracelimit)

> `static` **stackTraceLimit**: `number`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:67

The `Error.stackTraceLimit` property specifies the number of stack frames collected by a stack trace (whether generated by `new Error().stack` or `Error.captureStackTrace(obj)`).

The default value is `10` but may be set to any valid JavaScript number. Changes will affect any stack trace captured *after* the value has been changed.

If set to a non-number value, or set to a negative number, stack traces will not capture any frames.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

`Error.stackTraceLimit`

## Methods

[Section titled “Methods”](#methods)

### captureStackTrace()

[Section titled “captureStackTrace()”](#capturestacktrace)

> `static` **captureStackTrace**(`targetObject`, `constructorOpt?`): `void`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:51

Creates a `.stack` property on `targetObject`, which when accessed returns a string representing the location in the code at which `Error.captureStackTrace()` was called.

```js
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack;  // Similar to `new Error().stack`
```

The first line of the trace will be prefixed with `${myObject.name}: ${myObject.message}`.

The optional `constructorOpt` argument accepts a function. If given, all frames above `constructorOpt`, including `constructorOpt`, will be omitted from the generated stack trace.

The `constructorOpt` argument is useful for hiding implementation details of error generation from the user. For instance:

```js
function a() {
  b();
}


function b() {
  c();
}


function c() {
  // Create an error without stack trace to avoid calculating the stack trace twice.
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  const error = new Error();
  Error.stackTraceLimit = stackTraceLimit;


  // Capture the stack trace above function b
  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
  throw error;
}


a();
```

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### targetObject

[Section titled “targetObject”](#targetobject)

`object`

##### constructorOpt?

[Section titled “constructorOpt?”](#constructoropt)

`Function`

#### Returns

[Section titled “Returns”](#returns-1)

`void`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

`Error.captureStackTrace`

***

### prepareStackTrace()

[Section titled “prepareStackTrace()”](#preparestacktrace)

> `static` **prepareStackTrace**(`err`, `stackTraces`): `any`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:55

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### err

[Section titled “err”](#err)

`Error`

##### stackTraces

[Section titled “stackTraces”](#stacktraces)

`CallSite`\[]

#### Returns

[Section titled “Returns”](#returns-2)

`any`

#### See

[Section titled “See”](#see)

<https://v8.dev/docs/stack-trace-api#customizing-stack-traces>

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

`Error.prepareStackTrace`

# GameboardIoError

Defined in: [packages/declarative-hex-worlds/src/errors/index.ts:66](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/errors/index.ts#L66)

Thrown when ingest / bootstrap / file IO cannot proceed.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/)

## Constructors

[Section titled “Constructors”](#constructors)

### Constructor

[Section titled “Constructor”](#constructor)

> **new GameboardIoError**(`message`, `options?`): `GameboardIoError`

Defined in: [packages/declarative-hex-worlds/src/errors/index.ts:41](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/errors/index.ts#L41)

#### Parameters

[Section titled “Parameters”](#parameters)

##### message

[Section titled “message”](#message)

`string`

##### options?

[Section titled “options?”](#options)

###### cause?

[Section titled “cause?”](#cause)

`unknown`

#### Returns

[Section titled “Returns”](#returns)

`GameboardIoError`

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`constructor`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#constructor)

## Properties

[Section titled “Properties”](#properties)

### cause?

[Section titled “cause?”](#cause-1)

> `optional` **cause?**: `unknown`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:24

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`cause`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#cause)

***

### message

[Section titled “message”](#message-1)

> **message**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1075

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`message`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#message)

***

### name

[Section titled “name”](#name)

> **name**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1074

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`name`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#name)

***

### stack?

[Section titled “stack?”](#stack)

> `optional` **stack?**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1076

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`stack`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#stack)

***

### stackTraceLimit

[Section titled “stackTraceLimit”](#stacktracelimit)

> `static` **stackTraceLimit**: `number`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:67

The `Error.stackTraceLimit` property specifies the number of stack frames collected by a stack trace (whether generated by `new Error().stack` or `Error.captureStackTrace(obj)`).

The default value is `10` but may be set to any valid JavaScript number. Changes will affect any stack trace captured *after* the value has been changed.

If set to a non-number value, or set to a negative number, stack traces will not capture any frames.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`stackTraceLimit`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#stacktracelimit)

## Methods

[Section titled “Methods”](#methods)

### captureStackTrace()

[Section titled “captureStackTrace()”](#capturestacktrace)

> `static` **captureStackTrace**(`targetObject`, `constructorOpt?`): `void`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:51

Creates a `.stack` property on `targetObject`, which when accessed returns a string representing the location in the code at which `Error.captureStackTrace()` was called.

```js
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack;  // Similar to `new Error().stack`
```

The first line of the trace will be prefixed with `${myObject.name}: ${myObject.message}`.

The optional `constructorOpt` argument accepts a function. If given, all frames above `constructorOpt`, including `constructorOpt`, will be omitted from the generated stack trace.

The `constructorOpt` argument is useful for hiding implementation details of error generation from the user. For instance:

```js
function a() {
  b();
}


function b() {
  c();
}


function c() {
  // Create an error without stack trace to avoid calculating the stack trace twice.
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  const error = new Error();
  Error.stackTraceLimit = stackTraceLimit;


  // Capture the stack trace above function b
  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
  throw error;
}


a();
```

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### targetObject

[Section titled “targetObject”](#targetobject)

`object`

##### constructorOpt?

[Section titled “constructorOpt?”](#constructoropt)

`Function`

#### Returns

[Section titled “Returns”](#returns-1)

`void`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`captureStackTrace`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#capturestacktrace)

***

### prepareStackTrace()

[Section titled “prepareStackTrace()”](#preparestacktrace)

> `static` **prepareStackTrace**(`err`, `stackTraces`): `any`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:55

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### err

[Section titled “err”](#err)

`Error`

##### stackTraces

[Section titled “stackTraces”](#stacktraces)

`CallSite`\[]

#### Returns

[Section titled “Returns”](#returns-2)

`any`

#### See

[Section titled “See”](#see)

<https://v8.dev/docs/stack-trace-api#customizing-stack-traces>

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`prepareStackTrace`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#preparestacktrace)

# GameboardManifestError

Defined in: [packages/declarative-hex-worlds/src/errors/index.ts:51](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/errors/index.ts#L51)

Thrown when the manifest is malformed, missing assets, or version-incompatible.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/)

## Constructors

[Section titled “Constructors”](#constructors)

### Constructor

[Section titled “Constructor”](#constructor)

> **new GameboardManifestError**(`message`, `options?`): `GameboardManifestError`

Defined in: [packages/declarative-hex-worlds/src/errors/index.ts:41](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/errors/index.ts#L41)

#### Parameters

[Section titled “Parameters”](#parameters)

##### message

[Section titled “message”](#message)

`string`

##### options?

[Section titled “options?”](#options)

###### cause?

[Section titled “cause?”](#cause)

`unknown`

#### Returns

[Section titled “Returns”](#returns)

`GameboardManifestError`

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`constructor`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#constructor)

## Properties

[Section titled “Properties”](#properties)

### cause?

[Section titled “cause?”](#cause-1)

> `optional` **cause?**: `unknown`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:24

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`cause`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#cause)

***

### message

[Section titled “message”](#message-1)

> **message**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1075

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`message`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#message)

***

### name

[Section titled “name”](#name)

> **name**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1074

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`name`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#name)

***

### stack?

[Section titled “stack?”](#stack)

> `optional` **stack?**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1076

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`stack`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#stack)

***

### stackTraceLimit

[Section titled “stackTraceLimit”](#stacktracelimit)

> `static` **stackTraceLimit**: `number`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:67

The `Error.stackTraceLimit` property specifies the number of stack frames collected by a stack trace (whether generated by `new Error().stack` or `Error.captureStackTrace(obj)`).

The default value is `10` but may be set to any valid JavaScript number. Changes will affect any stack trace captured *after* the value has been changed.

If set to a non-number value, or set to a negative number, stack traces will not capture any frames.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`stackTraceLimit`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#stacktracelimit)

## Methods

[Section titled “Methods”](#methods)

### captureStackTrace()

[Section titled “captureStackTrace()”](#capturestacktrace)

> `static` **captureStackTrace**(`targetObject`, `constructorOpt?`): `void`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:51

Creates a `.stack` property on `targetObject`, which when accessed returns a string representing the location in the code at which `Error.captureStackTrace()` was called.

```js
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack;  // Similar to `new Error().stack`
```

The first line of the trace will be prefixed with `${myObject.name}: ${myObject.message}`.

The optional `constructorOpt` argument accepts a function. If given, all frames above `constructorOpt`, including `constructorOpt`, will be omitted from the generated stack trace.

The `constructorOpt` argument is useful for hiding implementation details of error generation from the user. For instance:

```js
function a() {
  b();
}


function b() {
  c();
}


function c() {
  // Create an error without stack trace to avoid calculating the stack trace twice.
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  const error = new Error();
  Error.stackTraceLimit = stackTraceLimit;


  // Capture the stack trace above function b
  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
  throw error;
}


a();
```

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### targetObject

[Section titled “targetObject”](#targetobject)

`object`

##### constructorOpt?

[Section titled “constructorOpt?”](#constructoropt)

`Function`

#### Returns

[Section titled “Returns”](#returns-1)

`void`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`captureStackTrace`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#capturestacktrace)

***

### prepareStackTrace()

[Section titled “prepareStackTrace()”](#preparestacktrace)

> `static` **prepareStackTrace**(`err`, `stackTraces`): `any`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:55

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### err

[Section titled “err”](#err)

`Error`

##### stackTraces

[Section titled “stackTraces”](#stacktraces)

`CallSite`\[]

#### Returns

[Section titled “Returns”](#returns-2)

`any`

#### See

[Section titled “See”](#see)

<https://v8.dev/docs/stack-trace-api#customizing-stack-traces>

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`prepareStackTrace`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#preparestacktrace)

# GameboardRuntimeError

Defined in: [packages/declarative-hex-worlds/src/errors/index.ts:60](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/errors/index.ts#L60)

Thrown when the runtime hits a state it cannot recover from (missing entity, broken trait shape, simulation invariant violated, etc.).

## Extends

[Section titled “Extends”](#extends)

* [`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/)

## Constructors

[Section titled “Constructors”](#constructors)

### Constructor

[Section titled “Constructor”](#constructor)

> **new GameboardRuntimeError**(`message`, `options?`): `GameboardRuntimeError`

Defined in: [packages/declarative-hex-worlds/src/errors/index.ts:41](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/errors/index.ts#L41)

#### Parameters

[Section titled “Parameters”](#parameters)

##### message

[Section titled “message”](#message)

`string`

##### options?

[Section titled “options?”](#options)

###### cause?

[Section titled “cause?”](#cause)

`unknown`

#### Returns

[Section titled “Returns”](#returns)

`GameboardRuntimeError`

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`constructor`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#constructor)

## Properties

[Section titled “Properties”](#properties)

### cause?

[Section titled “cause?”](#cause-1)

> `optional` **cause?**: `unknown`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:24

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`cause`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#cause)

***

### message

[Section titled “message”](#message-1)

> **message**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1075

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`message`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#message)

***

### name

[Section titled “name”](#name)

> **name**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1074

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`name`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#name)

***

### stack?

[Section titled “stack?”](#stack)

> `optional` **stack?**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1076

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`stack`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#stack)

***

### stackTraceLimit

[Section titled “stackTraceLimit”](#stacktracelimit)

> `static` **stackTraceLimit**: `number`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:67

The `Error.stackTraceLimit` property specifies the number of stack frames collected by a stack trace (whether generated by `new Error().stack` or `Error.captureStackTrace(obj)`).

The default value is `10` but may be set to any valid JavaScript number. Changes will affect any stack trace captured *after* the value has been changed.

If set to a non-number value, or set to a negative number, stack traces will not capture any frames.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`stackTraceLimit`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#stacktracelimit)

## Methods

[Section titled “Methods”](#methods)

### captureStackTrace()

[Section titled “captureStackTrace()”](#capturestacktrace)

> `static` **captureStackTrace**(`targetObject`, `constructorOpt?`): `void`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:51

Creates a `.stack` property on `targetObject`, which when accessed returns a string representing the location in the code at which `Error.captureStackTrace()` was called.

```js
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack;  // Similar to `new Error().stack`
```

The first line of the trace will be prefixed with `${myObject.name}: ${myObject.message}`.

The optional `constructorOpt` argument accepts a function. If given, all frames above `constructorOpt`, including `constructorOpt`, will be omitted from the generated stack trace.

The `constructorOpt` argument is useful for hiding implementation details of error generation from the user. For instance:

```js
function a() {
  b();
}


function b() {
  c();
}


function c() {
  // Create an error without stack trace to avoid calculating the stack trace twice.
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  const error = new Error();
  Error.stackTraceLimit = stackTraceLimit;


  // Capture the stack trace above function b
  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
  throw error;
}


a();
```

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### targetObject

[Section titled “targetObject”](#targetobject)

`object`

##### constructorOpt?

[Section titled “constructorOpt?”](#constructoropt)

`Function`

#### Returns

[Section titled “Returns”](#returns-1)

`void`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`captureStackTrace`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#capturestacktrace)

***

### prepareStackTrace()

[Section titled “prepareStackTrace()”](#preparestacktrace)

> `static` **prepareStackTrace**(`err`, `stackTraces`): `any`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:55

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### err

[Section titled “err”](#err)

`Error`

##### stackTraces

[Section titled “stackTraces”](#stacktraces)

`CallSite`\[]

#### Returns

[Section titled “Returns”](#returns-2)

`any`

#### See

[Section titled “See”](#see)

<https://v8.dev/docs/stack-trace-api#customizing-stack-traces>

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`prepareStackTrace`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#preparestacktrace)

# GameboardScenarioError

Defined in: [packages/declarative-hex-worlds/src/errors/index.ts:54](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/errors/index.ts#L54)

Thrown when a scenario JSON / blueprint / recipe fails to compile or load.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/)

## Constructors

[Section titled “Constructors”](#constructors)

### Constructor

[Section titled “Constructor”](#constructor)

> **new GameboardScenarioError**(`message`, `options?`): `GameboardScenarioError`

Defined in: [packages/declarative-hex-worlds/src/errors/index.ts:41](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/errors/index.ts#L41)

#### Parameters

[Section titled “Parameters”](#parameters)

##### message

[Section titled “message”](#message)

`string`

##### options?

[Section titled “options?”](#options)

###### cause?

[Section titled “cause?”](#cause)

`unknown`

#### Returns

[Section titled “Returns”](#returns)

`GameboardScenarioError`

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`constructor`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#constructor)

## Properties

[Section titled “Properties”](#properties)

### cause?

[Section titled “cause?”](#cause-1)

> `optional` **cause?**: `unknown`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:24

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`cause`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#cause)

***

### message

[Section titled “message”](#message-1)

> **message**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1075

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`message`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#message)

***

### name

[Section titled “name”](#name)

> **name**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1074

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`name`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#name)

***

### stack?

[Section titled “stack?”](#stack)

> `optional` **stack?**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1076

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`stack`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#stack)

***

### stackTraceLimit

[Section titled “stackTraceLimit”](#stacktracelimit)

> `static` **stackTraceLimit**: `number`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:67

The `Error.stackTraceLimit` property specifies the number of stack frames collected by a stack trace (whether generated by `new Error().stack` or `Error.captureStackTrace(obj)`).

The default value is `10` but may be set to any valid JavaScript number. Changes will affect any stack trace captured *after* the value has been changed.

If set to a non-number value, or set to a negative number, stack traces will not capture any frames.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`stackTraceLimit`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#stacktracelimit)

## Methods

[Section titled “Methods”](#methods)

### captureStackTrace()

[Section titled “captureStackTrace()”](#capturestacktrace)

> `static` **captureStackTrace**(`targetObject`, `constructorOpt?`): `void`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:51

Creates a `.stack` property on `targetObject`, which when accessed returns a string representing the location in the code at which `Error.captureStackTrace()` was called.

```js
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack;  // Similar to `new Error().stack`
```

The first line of the trace will be prefixed with `${myObject.name}: ${myObject.message}`.

The optional `constructorOpt` argument accepts a function. If given, all frames above `constructorOpt`, including `constructorOpt`, will be omitted from the generated stack trace.

The `constructorOpt` argument is useful for hiding implementation details of error generation from the user. For instance:

```js
function a() {
  b();
}


function b() {
  c();
}


function c() {
  // Create an error without stack trace to avoid calculating the stack trace twice.
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  const error = new Error();
  Error.stackTraceLimit = stackTraceLimit;


  // Capture the stack trace above function b
  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
  throw error;
}


a();
```

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### targetObject

[Section titled “targetObject”](#targetobject)

`object`

##### constructorOpt?

[Section titled “constructorOpt?”](#constructoropt)

`Function`

#### Returns

[Section titled “Returns”](#returns-1)

`void`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`captureStackTrace`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#capturestacktrace)

***

### prepareStackTrace()

[Section titled “prepareStackTrace()”](#preparestacktrace)

> `static` **prepareStackTrace**(`err`, `stackTraces`): `any`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:55

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### err

[Section titled “err”](#err)

`Error`

##### stackTraces

[Section titled “stackTraces”](#stacktraces)

`CallSite`\[]

#### Returns

[Section titled “Returns”](#returns-2)

`any`

#### See

[Section titled “See”](#see)

<https://v8.dev/docs/stack-trace-api#customizing-stack-traces>

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`prepareStackTrace`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#preparestacktrace)

# GameboardValidationError

Defined in: [packages/declarative-hex-worlds/src/errors/index.ts:48](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/errors/index.ts#L48)

Thrown when input data fails structural / domain validation.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/)

## Constructors

[Section titled “Constructors”](#constructors)

### Constructor

[Section titled “Constructor”](#constructor)

> **new GameboardValidationError**(`message`, `options?`): `GameboardValidationError`

Defined in: [packages/declarative-hex-worlds/src/errors/index.ts:41](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/errors/index.ts#L41)

#### Parameters

[Section titled “Parameters”](#parameters)

##### message

[Section titled “message”](#message)

`string`

##### options?

[Section titled “options?”](#options)

###### cause?

[Section titled “cause?”](#cause)

`unknown`

#### Returns

[Section titled “Returns”](#returns)

`GameboardValidationError`

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`constructor`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#constructor)

## Properties

[Section titled “Properties”](#properties)

### cause?

[Section titled “cause?”](#cause-1)

> `optional` **cause?**: `unknown`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:24

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`cause`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#cause)

***

### message

[Section titled “message”](#message-1)

> **message**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1075

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`message`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#message)

***

### name

[Section titled “name”](#name)

> **name**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1074

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`name`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#name)

***

### stack?

[Section titled “stack?”](#stack)

> `optional` **stack?**: `string`

Defined in: node\_modules/.pnpm/typescript\@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1076

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`stack`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#stack)

***

### stackTraceLimit

[Section titled “stackTraceLimit”](#stacktracelimit)

> `static` **stackTraceLimit**: `number`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:67

The `Error.stackTraceLimit` property specifies the number of stack frames collected by a stack trace (whether generated by `new Error().stack` or `Error.captureStackTrace(obj)`).

The default value is `10` but may be set to any valid JavaScript number. Changes will affect any stack trace captured *after* the value has been changed.

If set to a non-number value, or set to a negative number, stack traces will not capture any frames.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`stackTraceLimit`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#stacktracelimit)

## Methods

[Section titled “Methods”](#methods)

### captureStackTrace()

[Section titled “captureStackTrace()”](#capturestacktrace)

> `static` **captureStackTrace**(`targetObject`, `constructorOpt?`): `void`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:51

Creates a `.stack` property on `targetObject`, which when accessed returns a string representing the location in the code at which `Error.captureStackTrace()` was called.

```js
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack;  // Similar to `new Error().stack`
```

The first line of the trace will be prefixed with `${myObject.name}: ${myObject.message}`.

The optional `constructorOpt` argument accepts a function. If given, all frames above `constructorOpt`, including `constructorOpt`, will be omitted from the generated stack trace.

The `constructorOpt` argument is useful for hiding implementation details of error generation from the user. For instance:

```js
function a() {
  b();
}


function b() {
  c();
}


function c() {
  // Create an error without stack trace to avoid calculating the stack trace twice.
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  const error = new Error();
  Error.stackTraceLimit = stackTraceLimit;


  // Capture the stack trace above function b
  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
  throw error;
}


a();
```

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### targetObject

[Section titled “targetObject”](#targetobject)

`object`

##### constructorOpt?

[Section titled “constructorOpt?”](#constructoropt)

`Function`

#### Returns

[Section titled “Returns”](#returns-1)

`void`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`captureStackTrace`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#capturestacktrace)

***

### prepareStackTrace()

[Section titled “prepareStackTrace()”](#preparestacktrace)

> `static` **prepareStackTrace**(`err`, `stackTraces`): `any`

Defined in: node\_modules/.pnpm/@types+node\@26.1.0/node\_modules/@types/node/globals.d.ts:55

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### err

[Section titled “err”](#err)

`Error`

##### stackTraces

[Section titled “stackTraces”](#stacktraces)

`CallSite`\[]

#### Returns

[Section titled “Returns”](#returns-2)

`any`

#### See

[Section titled “See”](#see)

<https://v8.dev/docs/stack-trace-api#customizing-stack-traces>

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardError`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/).[`prepareStackTrace`](/declarative-hex-worlds/reference/errors/classes/gameboarderror/#preparestacktrace)

# createGameboardNavigation

> **createGameboardNavigation**(`plan`, `profile?`): [`GameboardNavigation`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigation/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:313](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L313)

Create a reusable navigation facade for pathfinding, reachability, and tile occupancy queries.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### profile?

[Section titled “profile?”](#profile)

[`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardNavigation`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigation/)

# createGameboardOccupancyIndex

> **createGameboardOccupancyIndex**(`plan`, `profile?`): [`GameboardOccupancyIndex`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardoccupancyindex/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:279](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L279)

Build an occupancy index for a plan under a navigation profile.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### profile?

[Section titled “profile?”](#profile)

[`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardOccupancyIndex`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardoccupancyindex/)

# findGameboardPath

> **findGameboardPath**(`plan`, `start`, `goal`, `profile?`, `tilesByKey?`, `occupancy?`): [`GameboardNavigationPathResult`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationpathresult/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:355](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L355)

Find the lowest-cost path between two tiles under a navigation profile.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### start

[Section titled “start”](#start)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### goal

[Section titled “goal”](#goal)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### profile?

[Section titled “profile?”](#profile)

[`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/) = `{}`

### tilesByKey?

[Section titled “tilesByKey?”](#tilesbykey)

`ReadonlyMap`<`string`, [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)> = `...`

### occupancy?

[Section titled “occupancy?”](#occupancy)

[`GameboardOccupancyIndex`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardoccupancyindex/) = `...`

## Returns

[Section titled “Returns”](#returns)

[`GameboardNavigationPathResult`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationpathresult/)

# planGameboardPatrolRoute

> **planGameboardPatrolRoute**(`plan`, `options`): `GameboardPatrolRoutePlan`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:528](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L528)

Plan one patrol route from an explicit start, a spawn-group start, or generated waypoints.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### options

[Section titled “options”](#options)

`GameboardPatrolRouteOptions`

## Returns

[Section titled “Returns”](#returns)

`GameboardPatrolRoutePlan`

# planGameboardPatrolRoutes

> **planGameboardPatrolRoutes**(`plan`, `options`): `GameboardPatrolRouteSet`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:539](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L539)

Plan a set of named patrol routes with shared spawn group and navigation defaults.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### options

[Section titled “options”](#options)

`GameboardPatrolRouteSetOptions`

## Returns

[Section titled “Returns”](#returns)

`GameboardPatrolRouteSet`

# planGameboardSpawnGroups

> **planGameboardSpawnGroups**(`plan`, `options`): `GameboardSpawnGroupPlan`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:517](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L517)

Plan multiple spawn groups in order, with optional inter-group distance and route checks.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### options

[Section titled “options”](#options)

`GameboardSpawnGroupOptions`

## Returns

[Section titled “Returns”](#returns)

`GameboardSpawnGroupPlan`

# reachableGameboardTiles

> **reachableGameboardTiles**(`plan`, `start`, `movementBudget`, `profile?`, `tilesByKey?`, `occupancy?`): [`GameboardReachableTile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardreachabletile/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:410](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L410)

Return all tiles reachable from a start tile within a movement budget.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### start

[Section titled “start”](#start)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### movementBudget

[Section titled “movementBudget”](#movementbudget)

`number`

### profile?

[Section titled “profile?”](#profile)

[`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/) = `{}`

### tilesByKey?

[Section titled “tilesByKey?”](#tilesbykey)

`ReadonlyMap`<`string`, [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)> = `...`

### occupancy?

[Section titled “occupancy?”](#occupancy)

[`GameboardOccupancyIndex`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardoccupancyindex/) = `...`

## Returns

[Section titled “Returns”](#returns)

[`GameboardReachableTile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardreachabletile/)\[]

# selectGameboardSpawnLocations

> **selectGameboardSpawnLocations**(`plan`, `options`): [`SpawnLocation`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocation/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:506](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L506)

Select deterministic spawn locations from passable plan tiles.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### options

[Section titled “options”](#options)

`GameboardSpawnLocationOptions`

## Returns

[Section titled “Returns”](#returns)

[`SpawnLocation`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocation/)\[]

# GameboardNavigation

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:109](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L109)

Reusable navigation facade for one plan/profile pair.

## Properties

[Section titled “Properties”](#properties)

### canEnter

[Section titled “canEnter”](#canenter)

> **canEnter**: (`coordinates`, `from?`) => `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:125](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L125)

Return whether a tile can be entered from an optional source tile.

#### Parameters

[Section titled “Parameters”](#parameters)

##### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### from?

[Section titled “from?”](#from)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns)

`boolean`

***

### findPath

[Section titled “findPath”](#findpath)

> **findPath**: (`start`, `goal`) => [`GameboardNavigationPathResult`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationpathresult/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:131](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L131)

Find a path between two tiles.

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### start

[Section titled “start”](#start)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### goal

[Section titled “goal”](#goal)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns-1)

[`GameboardNavigationPathResult`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationpathresult/)

***

### isBlocked

[Section titled “isBlocked”](#isblocked)

> **isBlocked**: (`coordinates`) => `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:123](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L123)

Return whether a tile key or coordinates are blocked.

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### coordinates

[Section titled “coordinates”](#coordinates-1)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns-2)

`boolean`

***

### movementCost

[Section titled “movementCost”](#movementcost)

> **movementCost**: (`from`, `to`) => `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:127](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L127)

Calculate movement cost between adjacent tiles.

#### Parameters

[Section titled “Parameters”](#parameters-3)

##### from

[Section titled “from”](#from-1)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### to

[Section titled “to”](#to)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns-3)

`number`

***

### neighbors

[Section titled “neighbors”](#neighbors)

> **neighbors**: (`coordinates`) => [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:129](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L129)

Return neighboring tiles inside the board.

#### Parameters

[Section titled “Parameters”](#parameters-4)

##### coordinates

[Section titled “coordinates”](#coordinates-2)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns-4)

[`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)\[]

***

### occupancy

[Section titled “occupancy”](#occupancy)

> **occupancy**: [`GameboardOccupancyIndex`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardoccupancyindex/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:117](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L117)

Occupancy lookup for the plan/profile pair.

***

### placementsAt

[Section titled “placementsAt”](#placementsat)

> **placementsAt**: (`coordinates`) => readonly [`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:121](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L121)

Read placements occupying a tile.

#### Parameters

[Section titled “Parameters”](#parameters-5)

##### coordinates

[Section titled “coordinates”](#coordinates-3)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns-5)

readonly [`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)\[]

***

### plan

[Section titled “plan”](#plan)

> **plan**: [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:111](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L111)

Board plan being navigated.

***

### profile

[Section titled “profile”](#profile)

> **profile**: [`RequiredGameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/requiredgameboardnavigationprofile/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:113](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L113)

Normalized required navigation profile.

***

### reachable

[Section titled “reachable”](#reachable)

> **reachable**: (`start`, `movementBudget`) => [`GameboardReachableTile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardreachabletile/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L136)

Return tiles reachable from a start tile within a movement budget.

#### Parameters

[Section titled “Parameters”](#parameters-6)

##### start

[Section titled “start”](#start-1)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### movementBudget

[Section titled “movementBudget”](#movementbudget)

`number`

#### Returns

[Section titled “Returns”](#returns-6)

[`GameboardReachableTile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardreachabletile/)\[]

***

### tileAt

[Section titled “tileAt”](#tileat)

> **tileAt**: (`coordinates`) => [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:119](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L119)

Resolve a tile from coordinates or tile key.

#### Parameters

[Section titled “Parameters”](#parameters-7)

##### coordinates

[Section titled “coordinates”](#coordinates-4)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns-7)

[`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/) | `undefined`

***

### tilesByKey

[Section titled “tilesByKey”](#tilesbykey)

> **tilesByKey**: `ReadonlyMap`<`string`, [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)>

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:115](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L115)

Tile lookup by tile key.

# GameboardNavigationContext

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:83](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L83)

Context passed to custom navigation profile hooks.

## Properties

[Section titled “Properties”](#properties)

### from?

[Section titled “from?”](#from)

> `optional` **from?**: [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:87](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L87)

Source tile for this movement step, when known.

***

### placements

[Section titled “placements”](#placements)

> **placements**: readonly [`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:91](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L91)

Placements occupying the destination tile.

***

### plan

[Section titled “plan”](#plan)

> **plan**: [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:85](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L85)

Board plan being navigated.

***

### to

[Section titled “to”](#to)

> **to**: [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:89](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L89)

Destination tile being evaluated.

# GameboardNavigationPathResult

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:170](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L170)

Pathfinding result between two tiles.

## Properties

[Section titled “Properties”](#properties)

### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: readonly [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:176](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L176)

Coordinates along the route.

***

### cost

[Section titled “cost”](#cost)

> **cost**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:178](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L178)

Total route cost.

***

### found

[Section titled “found”](#found)

> **found**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:172](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L172)

Whether a route was found.

***

### path

[Section titled “path”](#path)

> **path**: readonly [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:174](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L174)

Tile specs along the route.

***

### visited

[Section titled “visited”](#visited)

> **visited**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:180](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L180)

Number of nodes visited by the pathfinder.

# GameboardNavigationProfile

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:55](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L55)

Pathfinding profile for terrain, elevation, occupancy, and custom movement rules.

## Properties

[Section titled “Properties”](#properties)

### allowedTerrain?

[Section titled “allowedTerrain?”](#allowedterrain)

> `optional` **allowedTerrain?**: readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:57](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L57)

Terrain values the profile may enter. Undefined means all except blocked terrain.

***

### allowGoalBlocked?

[Section titled “allowGoalBlocked?”](#allowgoalblocked)

> `optional` **allowGoalBlocked?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:73](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L73)

Whether the goal tile may be blocked.

***

### allowStartBlocked?

[Section titled “allowStartBlocked?”](#allowstartblocked)

> `optional` **allowStartBlocked?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:71](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L71)

Whether the start tile may be blocked.

***

### blockedTerrain?

[Section titled “blockedTerrain?”](#blockedterrain)

> `optional` **blockedTerrain?**: readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:59](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L59)

Terrain values the profile may not enter.

***

### blockingPlacementKinds?

[Section titled “blockingPlacementKinds?”](#blockingplacementkinds)

> `optional` **blockingPlacementKinds?**: readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:63](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L63)

Placement kinds that block movement.

***

### blockingPlacementLayers?

[Section titled “blockingPlacementLayers?”](#blockingplacementlayers)

> `optional` **blockingPlacementLayers?**: readonly [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L65)

Placement layers that block movement.

***

### canEnter?

[Section titled “canEnter?”](#canenter)

> `optional` **canEnter?**: (`tile`, `context`) => `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:75](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L75)

Optional custom tile-entry predicate.

#### Parameters

[Section titled “Parameters”](#parameters)

##### tile

[Section titled “tile”](#tile)

[`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)

##### context

[Section titled “context”](#context)

[`GameboardNavigationContext`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationcontext/)

#### Returns

[Section titled “Returns”](#returns)

`boolean`

***

### cost?

[Section titled “cost?”](#cost)

> `optional` **cost?**: (`from`, `to`, `baseCost`) => `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:77](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L77)

Optional custom movement-cost function.

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### from

[Section titled “from”](#from)

[`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)

##### to

[Section titled “to”](#to)

[`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)

##### baseCost

[Section titled “baseCost”](#basecost)

`number`

#### Returns

[Section titled “Returns”](#returns-1)

`number`

***

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L67)

Placement ids ignored by occupancy checks.

***

### maxElevationStep?

[Section titled “maxElevationStep?”](#maxelevationstep)

> `optional` **maxElevationStep?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:69](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L69)

Maximum allowed elevation change between adjacent tiles.

***

### terrainCosts?

[Section titled “terrainCosts?”](#terraincosts)

> `optional` **terrainCosts?**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:61](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L61)

Additional movement costs by terrain value.

# GameboardOccupancyIndex

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:97](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L97)

Occupancy index used by navigation and spawn planning.

## Properties

[Section titled “Properties”](#properties)

### blockingTileKeys

[Section titled “blockingTileKeys”](#blockingtilekeys)

> **blockingTileKeys**: `ReadonlySet`<`string`>

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:103](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L103)

Tile keys occupied by blocking placement footprints.

***

### byTileKey

[Section titled “byTileKey”](#bytilekey)

> **byTileKey**: `ReadonlyMap`<`string`, readonly [`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)\[]>

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:99](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L99)

Placements grouped by occupied tile key.

***

### occupiedTileKeys

[Section titled “occupiedTileKeys”](#occupiedtilekeys)

> **occupiedTileKeys**: `ReadonlySet`<`string`>

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:101](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L101)

Tile keys occupied by any placement footprint.

# GameboardReachableTile

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:186](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L186)

Reachable tile and accumulated movement cost.

## Properties

[Section titled “Properties”](#properties)

### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:190](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L190)

Reachable tile coordinates.

***

### cost

[Section titled “cost”](#cost)

> **cost**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:192](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L192)

Movement cost from the start tile.

***

### tile

[Section titled “tile”](#tile)

> **tile**: [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:188](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L188)

Reachable tile.

# RequiredGameboardNavigationProfile

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:142](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L142)

Fully normalized navigation profile used internally and exposed for debugging.

## Properties

[Section titled “Properties”](#properties)

### allowedTerrain?

[Section titled “allowedTerrain?”](#allowedterrain)

> `optional` **allowedTerrain?**: readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:144](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L144)

Terrain values the profile may enter. Undefined means all except blocked terrain.

***

### allowGoalBlocked

[Section titled “allowGoalBlocked”](#allowgoalblocked)

> **allowGoalBlocked**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:160](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L160)

Whether the goal tile may be blocked.

***

### allowStartBlocked

[Section titled “allowStartBlocked”](#allowstartblocked)

> **allowStartBlocked**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:158](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L158)

Whether the start tile may be blocked.

***

### blockedTerrain

[Section titled “blockedTerrain”](#blockedterrain)

> **blockedTerrain**: readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:146](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L146)

Terrain values the profile may not enter.

***

### blockingPlacementKinds

[Section titled “blockingPlacementKinds”](#blockingplacementkinds)

> **blockingPlacementKinds**: readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:150](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L150)

Placement kinds that block movement.

***

### blockingPlacementLayers

[Section titled “blockingPlacementLayers”](#blockingplacementlayers)

> **blockingPlacementLayers**: readonly [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:152](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L152)

Placement layers that block movement.

***

### canEnter?

[Section titled “canEnter?”](#canenter)

> `optional` **canEnter?**: (`tile`, `context`) => `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:162](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L162)

Optional custom tile-entry predicate.

#### Parameters

[Section titled “Parameters”](#parameters)

##### tile

[Section titled “tile”](#tile)

[`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)

##### context

[Section titled “context”](#context)

[`GameboardNavigationContext`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationcontext/)

#### Returns

[Section titled “Returns”](#returns)

`boolean`

***

### cost?

[Section titled “cost?”](#cost)

> `optional` **cost?**: (`from`, `to`, `baseCost`) => `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:164](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L164)

Optional custom movement-cost function.

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### from

[Section titled “from”](#from)

[`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)

##### to

[Section titled “to”](#to)

[`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)

##### baseCost

[Section titled “baseCost”](#basecost)

`number`

#### Returns

[Section titled “Returns”](#returns-1)

`number`

***

### ignorePlacementIds

[Section titled “ignorePlacementIds”](#ignoreplacementids)

> **ignorePlacementIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:154](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L154)

Placement ids ignored by occupancy checks.

***

### maxElevationStep

[Section titled “maxElevationStep”](#maxelevationstep)

> **maxElevationStep**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:156](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L156)

Maximum allowed elevation change between adjacent tiles.

***

### terrainCosts

[Section titled “terrainCosts”](#terraincosts)

> **terrainCosts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:148](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L148)

Additional movement costs by terrain value.

# GameboardPatrolRouteOptions

> **GameboardPatrolRouteOptions** = `GameboardPatrolRouteOptionsCore`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:243](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L243)

Options for planning one patrol route.

# GameboardPatrolRoutePlan

> **GameboardPatrolRoutePlan** = `GameboardPatrolRoutePlanCore`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:258](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L258)

Planned patrol route with waypoints, segments, and diagnostics.

# GameboardPatrolRouteRule

> **GameboardPatrolRouteRule** = `GameboardPatrolRouteRuleCore`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:248](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L248)

Named patrol route rule for route-set planning.

# GameboardPatrolRouteSegment

> **GameboardPatrolRouteSegment** = `GameboardPatrolRouteSegmentCore`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:238](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L238)

One path segment between patrol waypoints.

# GameboardPatrolRouteSet

> **GameboardPatrolRouteSet** = `GameboardPatrolRouteSetCore`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:263](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L263)

Result for planning a set of patrol routes.

# GameboardPatrolRouteSetOptions

> **GameboardPatrolRouteSetOptions** = `GameboardPatrolRouteSetOptionsCore`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:253](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L253)

Options for planning several patrol routes.

# GameboardPatrolWaypoint

> **GameboardPatrolWaypoint** = `GameboardPatrolWaypointCore`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:233](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L233)

Spawn location promoted to a patrol waypoint.

# GameboardPatrolWaypointSource

> **GameboardPatrolWaypointSource** = `GameboardPatrolWaypointSourceCore`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:228](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L228)

Source used to create a patrol waypoint.

# GameboardSpawnGroup

> **GameboardSpawnGroup** = `GameboardSpawnGroupCore`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:218](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L218)

Selected spawn group with diagnostics.

# GameboardSpawnGroupOptions

> **GameboardSpawnGroupOptions** = `GameboardSpawnGroupOptionsCore`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:208](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L208)

Options for selecting several spawn groups in sequence.

# GameboardSpawnGroupPlan

> **GameboardSpawnGroupPlan** = `GameboardSpawnGroupPlanCore`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:223](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L223)

Complete spawn group planning result.

# GameboardSpawnGroupRoute

> **GameboardSpawnGroupRoute** = `GameboardSpawnGroupRouteCore`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:213](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L213)

Route check between two spawn groups.

# GameboardSpawnGroupRule

> **GameboardSpawnGroupRule** = `GameboardSpawnGroupRuleCore`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:203](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L203)

Rule for selecting one spawn group and checking routes to earlier groups.

# GameboardSpawnLocationOptions

> **GameboardSpawnLocationOptions** = `GameboardSpawnLocationOptionsCore`

Defined in: [packages/declarative-hex-worlds/src/gameboard/navigation.ts:198](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/navigation.ts#L198)

Options for selecting spawn locations from a gameboard plan.

# gameboardPlacementBlocksOccupancy

> **gameboardPlacementBlocksOccupancy**(`placement`, `options?`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/occupancy.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/occupancy.ts#L67)

Checks whether a placement should block another placement from occupying the same tile.

## Parameters

[Section titled “Parameters”](#parameters)

### placement

[Section titled “placement”](#placement)

[`GameboardPlacementOccupancyLike`](/declarative-hex-worlds/reference/gameboard/occupancy/interfaces/gameboardplacementoccupancylike/)

### options?

[Section titled “options?”](#options)

[`GameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/gameboard/occupancy/interfaces/gameboardplacementoccupancyoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

`boolean`

# gameboardPlacementFootprintKeys

> **gameboardPlacementFootprintKeys**(`placement`, `options?`): `string`\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/occupancy.ts:43](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/occupancy.ts#L43)

Returns every tile key occupied by a placement footprint.

## Parameters

[Section titled “Parameters”](#parameters)

### placement

[Section titled “placement”](#placement)

`Pick`<[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/), `"tileKey"` | `"metadata"`>

### options?

[Section titled “options?”](#options)

`Pick`<[`GameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/gameboard/occupancy/interfaces/gameboardplacementoccupancyoptions/), `"includeLayoutFootprint"`> = `{}`

## Returns

[Section titled “Returns”](#returns)

`string`\[]

# gameboardPlacementOccupancyGroup

> **gameboardPlacementOccupancyGroup**(`placement`): `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/occupancy.ts:83](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/occupancy.ts#L83)

Returns the occupancy group id used to collapse multi-placement composites.

## Parameters

[Section titled “Parameters”](#parameters)

### placement

[Section titled “placement”](#placement)

`Pick`<[`GameboardPlacementOccupancyLike`](/declarative-hex-worlds/reference/gameboard/occupancy/interfaces/gameboardplacementoccupancylike/), `"id"` | `"metadata"`>

## Returns

[Section titled “Returns”](#returns)

`string`

# gameboardPlacementOccupiesTile

> **gameboardPlacementOccupiesTile**(`placement`, `tileKey`, `options?`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/occupancy.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/occupancy.ts#L58)

Checks whether a placement footprint includes a tile key.

## Parameters

[Section titled “Parameters”](#parameters)

### placement

[Section titled “placement”](#placement)

`Pick`<[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/), `"tileKey"` | `"metadata"`>

### tileKey

[Section titled “tileKey”](#tilekey)

`string`

### options?

[Section titled “options?”](#options)

`Pick`<[`GameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/gameboard/occupancy/interfaces/gameboardplacementoccupancyoptions/), `"includeLayoutFootprint"`> = `{}`

## Returns

[Section titled “Returns”](#returns)

`boolean`

# GameboardPlacementOccupancyLike

Defined in: [packages/declarative-hex-worlds/src/gameboard/occupancy.ts:14](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/occupancy.ts#L14)

Minimal placement shape required by occupancy helpers.

## Properties

[Section titled “Properties”](#properties)

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/occupancy.ts:16](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/occupancy.ts#L16)

Placement id.

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/occupancy.ts:20](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/occupancy.ts#L20)

Placement kind used by blocking rules.

***

### layer

[Section titled “layer”](#layer)

> **layer**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/occupancy.ts:22](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/occupancy.ts#L22)

Placement layer used by blocking rules.

***

### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/gameboard/occupancy.ts:24](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/occupancy.ts#L24)

Placement metadata, including layout footprint and blocking hints.

***

### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/occupancy.ts:18](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/occupancy.ts#L18)

Primary tile occupied by the placement.

# GameboardPlacementOccupancyOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/occupancy.ts:28](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/occupancy.ts#L28)

Options controlling occupancy and blocking checks.

## Properties

[Section titled “Properties”](#properties)

### blockingPlacementKinds?

[Section titled “blockingPlacementKinds?”](#blockingplacementkinds)

> `optional` **blockingPlacementKinds?**: readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/occupancy.ts:32](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/occupancy.ts#L32)

Placement kinds that should block occupancy by default.

***

### blockingPlacementLayers?

[Section titled “blockingPlacementLayers?”](#blockingplacementlayers)

> `optional` **blockingPlacementLayers?**: readonly [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/occupancy.ts:34](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/occupancy.ts#L34)

Placement layers that should block occupancy by default.

***

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/occupancy.ts:36](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/occupancy.ts#L36)

Placement ids ignored by blocking checks.

***

### includeLayoutFootprint?

[Section titled “includeLayoutFootprint?”](#includelayoutfootprint)

> `optional` **includeLayoutFootprint?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/occupancy.ts:30](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/occupancy.ts#L30)

Whether to include `layoutFootprintTiles` metadata in occupied tile checks.

# GameboardBuilder

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:101](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L101)

Fluent builder for deterministic gameboard plans using KayKit guide variants, stacked terrain, roads, rivers, harbors, settlements, props, and EXTRA units.

## Constructors

[Section titled “Constructors”](#constructors)

### Constructor

[Section titled “Constructor”](#constructor)

> **new GameboardBuilder**(`options`): `GameboardBuilder`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:117](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L117)

Create a builder and initialize all tiles in the requested shape.

#### Parameters

[Section titled “Parameters”](#parameters)

##### options

[Section titled “options”](#options)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/)

#### Returns

[Section titled “Returns”](#returns)

`GameboardBuilder`

## Properties

[Section titled “Properties”](#properties)

### seed

[Section titled “seed”](#seed)

> `readonly` **seed**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:103](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L103)

Seed used by deterministic builder helpers.

***

### shape

[Section titled “shape”](#shape)

> `readonly` **shape**: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:105](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L105)

Shape populated by this builder.

***

### textureSet

[Section titled “textureSet”](#textureset)

> `readonly` **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:107](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L107)

Texture set applied to generated terrain.

## Methods

[Section titled “Methods”](#methods)

### addBridge()

[Section titled “addBridge()”](#addbridge)

> **addBridge**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:365](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L365)

Add a bridge structure with bridge-specific metadata instead of requiring callers to know the raw neutral-structure asset ids.

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### options

[Section titled “options”](#options-1)

[`BridgeOptions`](/declarative-hex-worlds/reference/index/interfaces/bridgeoptions/)

#### Returns

[Section titled “Returns”](#returns-1)

`this`

***

### addConstructionSite()

[Section titled “addConstructionSite()”](#addconstructionsite)

> **addConstructionSite**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:411](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L411)

Add a construction, ruin, or worksite structure with construction metadata.

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### options

[Section titled “options”](#options-2)

[`ConstructionSiteOptions`](/declarative-hex-worlds/reference/index/interfaces/constructionsiteoptions/)

#### Returns

[Section titled “Returns”](#returns-2)

`this`

***

### addElevationRamp()

[Section titled “addElevationRamp()”](#addelevationramp)

> **addElevationRamp**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:455](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L455)

Add a sloped grass ramp with ramp-specific metadata instead of requiring callers to place `hex_grass_sloped_high` or `hex_grass_sloped_low` directly.

#### Parameters

[Section titled “Parameters”](#parameters-3)

##### options

[Section titled “options”](#options-3)

[`ElevationRampOptions`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/)

#### Returns

[Section titled “Returns”](#returns-3)

`this`

***

### addFactionBuilding()

[Section titled “addFactionBuilding()”](#addfactionbuilding)

> **addFactionBuilding**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:331](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L331)

Add a faction building structure placement.

#### Parameters

[Section titled “Parameters”](#parameters-4)

##### options

[Section titled “options”](#options-4)

[`FactionBuildingOptions`](/declarative-hex-worlds/reference/index/interfaces/factionbuildingoptions/)

#### Returns

[Section titled “Returns”](#returns-4)

`this`

***

### addFlag()

[Section titled “addFlag()”](#addflag)

> **addFlag**(`at`, `faction`, `options?`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:518](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L518)

Add a faction flag prop placement.

#### Parameters

[Section titled “Parameters”](#parameters-5)

##### at

[Section titled “at”](#at)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### faction

[Section titled “faction”](#faction)

`"blue"` | `"green"` | `"red"` | `"yellow"`

##### options?

[Section titled “options?”](#options-5)

###### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

`number`

###### scale?

[Section titled “scale?”](#scale)

`number`

#### Returns

[Section titled “Returns”](#returns-5)

`this`

***

### addForest()

[Section titled “addForest()”](#addforest)

> **addForest**(`coordinates`, `options?`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:300](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L300)

Add a forest decoration and mark the tile as forest terrain.

#### Parameters

[Section titled “Parameters”](#parameters-6)

##### coordinates

[Section titled “coordinates”](#coordinates)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### options?

[Section titled “options?”](#options-6)

###### cut?

[Section titled “cut?”](#cut)

`boolean`

###### size?

[Section titled “size?”](#size)

`"small"` | `"medium"` | `"large"`

###### species?

[Section titled “species?”](#species)

`"A"` | `"B"`

#### Returns

[Section titled “Returns”](#returns-6)

`this`

***

### addFortification()

[Section titled “addFortification()”](#addfortification)

> **addFortification**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:386](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L386)

Add a wall or fence segment with fortification metadata.

#### Parameters

[Section titled “Parameters”](#parameters-7)

##### options

[Section titled “options”](#options-7)

[`FortificationOptions`](/declarative-hex-worlds/reference/index/interfaces/fortificationoptions/)

#### Returns

[Section titled “Returns”](#returns-7)

`this`

***

### addHarbor()

[Section titled “addHarbor()”](#addharbor)

> **addHarbor**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:673](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L673)

Add a harbor structure, mark the coast/water relationship, and optionally place adjacent water props.

#### Parameters

[Section titled “Parameters”](#parameters-8)

##### options

[Section titled “options”](#options-8)

[`HarborOptions`](/declarative-hex-worlds/reference/index/interfaces/harboroptions/)

#### Returns

[Section titled “Returns”](#returns-8)

`this`

***

### addHill()

[Section titled “addHill()”](#addhill)

> **addHill**(`coordinates`, `options?`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:275](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L275)

Add a hill decoration and mark the tile as hill terrain.

#### Parameters

[Section titled “Parameters”](#parameters-9)

##### coordinates

[Section titled “coordinates”](#coordinates-1)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### options?

[Section titled “options?”](#options-9)

###### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps-1)

`number`

###### single?

[Section titled “single?”](#single)

`boolean`

###### variant?

[Section titled “variant?”](#variant)

[`HillVariant`](/declarative-hex-worlds/reference/index/type-aliases/hillvariant/)

###### withTrees?

[Section titled “withTrees?”](#withtrees)

`boolean`

#### Returns

[Section titled “Returns”](#returns-9)

`this`

***

### addMountainStack()

[Section titled “addMountainStack()”](#addmountainstack)

> **addMountainStack**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:247](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L247)

Add an elevated mountain tile plus a visible mountain-stack placement.

#### Parameters

[Section titled “Parameters”](#parameters-10)

##### options

[Section titled “options”](#options-10)

[`MountainStackOptions`](/declarative-hex-worlds/reference/index/interfaces/mountainstackoptions/)

#### Returns

[Section titled “Returns”](#returns-10)

`this`

***

### addNature()

[Section titled “addNature()”](#addnature)

> **addNature**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:486](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L486)

Add a nature decoration placement.

#### Parameters

[Section titled “Parameters”](#parameters-11)

##### options

[Section titled “options”](#options-11)

[`NaturePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/natureplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-11)

`this`

***

### addNeutralStructure()

[Section titled “addNeutralStructure()”](#addneutralstructure)

> **addNeutralStructure**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:348](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L348)

Add a neutral structure placement.

#### Parameters

[Section titled “Parameters”](#parameters-12)

##### options

[Section titled “options”](#options-12)

[`NeutralStructureOptions`](/declarative-hex-worlds/reference/index/interfaces/neutralstructureoptions/)

#### Returns

[Section titled “Returns”](#returns-12)

`this`

***

### addPlacement()

[Section titled “addPlacement()”](#addplacement)

> **addPlacement**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:746](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L746)

Add a custom placement to the plan.

#### Parameters

[Section titled “Parameters”](#parameters-13)

##### options

[Section titled “options”](#options-13)

###### assetId

[Section titled “assetId”](#assetid)

`string`

###### at

[Section titled “at”](#at-1)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

###### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

`number`

###### kind

[Section titled “kind”](#kind)

[`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

###### layer

[Section titled “layer”](#layer)

[`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

###### metadata?

[Section titled “metadata?”](#metadata)

`Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

###### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

`boolean`

###### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps-2)

`number`

###### scale?

[Section titled “scale?”](#scale-1)

`number`

###### stackIndex?

[Section titled “stackIndex?”](#stackindex)

`number`

#### Returns

[Section titled “Returns”](#returns-13)

`this`

***

### addProp()

[Section titled “addProp()”](#addprop)

> **addProp**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:502](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L502)

Add a prop placement.

#### Parameters

[Section titled “Parameters”](#parameters-14)

##### options

[Section titled “options”](#options-14)

[`PropPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/propplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-14)

`this`

***

### addPropCluster()

[Section titled “addPropCluster()”](#addpropcluster)

> **addPropCluster**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:530](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L530)

Add a semantic prop cluster such as a camp, worksite, stable yard, or cache.

#### Parameters

[Section titled “Parameters”](#parameters-15)

##### options

[Section titled “options”](#options-15)

[`PropClusterOptions`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/)

#### Returns

[Section titled “Returns”](#returns-15)

`this`

***

### addRiverPath()

[Section titled “addRiverPath()”](#addriverpath)

> **addRiverPath**(`path`, `options?`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:227](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L227)

Add river connectivity along a coordinate path.

#### Parameters

[Section titled “Parameters”](#parameters-16)

##### path

[Section titled “path”](#path)

readonly [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

##### options?

[Section titled “options?”](#options-16)

###### crossing?

[Section titled “crossing?”](#crossing)

`"A"` | `"B"`

###### curvy?

[Section titled “curvy?”](#curvy)

`boolean`

###### waterless?

[Section titled “waterless?”](#waterless)

`boolean`

#### Returns

[Section titled “Returns”](#returns-16)

`this`

***

### addRoadPath()

[Section titled “addRoadPath()”](#addroadpath)

> **addRoadPath**(`path`, `options?`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:209](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L209)

Add road connectivity along a coordinate path.

#### Parameters

[Section titled “Parameters”](#parameters-17)

##### path

[Section titled “path”](#path-1)

readonly [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

##### options?

[Section titled “options?”](#options-17)

###### slope?

[Section titled “slope?”](#slope)

`"high"` | `"low"`

#### Returns

[Section titled “Returns”](#returns-17)

`this`

***

### addSettlement()

[Section titled “addSettlement()”](#addsettlement)

> **addSettlement**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:324](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L324)

Add a settlement building. Alias for `addFactionBuilding`.

#### Parameters

[Section titled “Parameters”](#parameters-18)

##### options

[Section titled “options”](#options-18)

[`SettlementOptions`](/declarative-hex-worlds/reference/index/interfaces/settlementoptions/)

#### Returns

[Section titled “Returns”](#returns-18)

`this`

***

### addSiegeProjectile()

[Section titled “addSiegeProjectile()”](#addsiegeprojectile)

> **addSiegeProjectile**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:432](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L432)

Add a neutral siege projectile with projectile-specific metadata.

#### Parameters

[Section titled “Parameters”](#parameters-19)

##### options

[Section titled “options”](#options-19)

[`SiegeProjectileOptions`](/declarative-hex-worlds/reference/index/interfaces/siegeprojectileoptions/)

#### Returns

[Section titled “Returns”](#returns-19)

`this`

***

### addTransition()

[Section titled “addTransition()”](#addtransition)

> **addTransition**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:577](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L577)

Add an EXTRA texture transition placement.

#### Parameters

[Section titled “Parameters”](#parameters-20)

##### options

[Section titled “options”](#options-20)

[`TransitionPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/transitionplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-20)

`this`

***

### addUnit()

[Section titled “addUnit()”](#addunit)

> **addUnit**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:594](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L594)

Add one unit part placement from the EXTRA unit library.

#### Parameters

[Section titled “Parameters”](#parameters-21)

##### options

[Section titled “options”](#options-21)

[`UnitPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-21)

`this`

***

### addUnitPreset()

[Section titled “addUnitPreset()”](#addunitpreset)

> **addUnitPreset**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:622](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L622)

Add a predefined multi-part unit composition.

#### Parameters

[Section titled “Parameters”](#parameters-22)

##### options

[Section titled “options”](#options-22)

[`UnitPresetOptions`](/declarative-hex-worlds/reference/index/interfaces/unitpresetoptions/)

#### Returns

[Section titled “Returns”](#returns-22)

`this`

***

### build()

[Section titled “build()”](#build)

> **build**(): [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:787](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L787)

Build an immutable gameboard plan from current builder state.

#### Returns

[Section titled “Returns”](#returns-23)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

***

### scatterDecorations()

[Section titled “scatterDecorations()”](#scatterdecorations)

> **scatterDecorations**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:708](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L708)

Scatter random decoration placements across matching terrain.

#### Parameters

[Section titled “Parameters”](#parameters-23)

##### options

[Section titled “options”](#options-23)

[`ScatterDecorationOptions`](/declarative-hex-worlds/reference/index/interfaces/scatterdecorationoptions/)

#### Returns

[Section titled “Returns”](#returns-24)

`this`

***

### setCoastEdges()

[Section titled “setCoastEdges()”](#setcoastedges)

> **setCoastEdges**(`coordinates`, `waterEdges`, `options?`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:190](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L190)

Mark a tile as coast and set the edges that face water.

#### Parameters

[Section titled “Parameters”](#parameters-24)

##### coordinates

[Section titled “coordinates”](#coordinates-2)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### waterEdges

[Section titled “waterEdges”](#wateredges)

`number` | readonly [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)\[]

##### options?

[Section titled “options?”](#options-24)

###### waterless?

[Section titled “waterless?”](#waterless-1)

`boolean`

#### Returns

[Section titled “Returns”](#returns-25)

`this`

***

### setElevation()

[Section titled “setElevation()”](#setelevation)

> **setElevation**(`coordinates`, `elevation`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:180](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L180)

Set the elevation for an existing tile.

#### Parameters

[Section titled “Parameters”](#parameters-25)

##### coordinates

[Section titled “coordinates”](#coordinates-3)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### elevation

[Section titled “elevation”](#elevation)

`number`

#### Returns

[Section titled “Returns”](#returns-26)

`this`

***

### setTerrain()

[Section titled “setTerrain()”](#setterrain)

> **setTerrain**(`coordinates`, `terrain`, `options?`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:132](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L132)

Set a base grass or water terrain tile.

#### Parameters

[Section titled “Parameters”](#parameters-26)

##### coordinates

[Section titled “coordinates”](#coordinates-4)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### terrain

[Section titled “terrain”](#terrain)

`"grass"` | `"water"`

##### options?

[Section titled “options?”](#options-25)

###### baseAssetId?

[Section titled “baseAssetId?”](#baseassetid)

`string`

###### elevation?

[Section titled “elevation?”](#elevation-1)

`number`

###### textureSet?

[Section titled “textureSet?”](#textureset-1)

`"default"` | `"fall"` | `"summer"` | `"winter"`

#### Returns

[Section titled “Returns”](#returns-27)

`this`

***

### setTextureSet()

[Section titled “setTextureSet()”](#settextureset)

> **setTextureSet**(`coordinates`, `textureSet`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:171](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L171)

Set the texture set for an existing tile without changing its terrain.

#### Parameters

[Section titled “Parameters”](#parameters-27)

##### coordinates

[Section titled “coordinates”](#coordinates-5)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### textureSet

[Section titled “textureSet”](#textureset-2)

`"default"` | `"fall"` | `"summer"` | `"winter"`

#### Returns

[Section titled “Returns”](#returns-28)

`this`

***

### setTileAsset()

[Section titled “setTileAsset()”](#settileasset)

> **setTileAsset**(`options`): `this`

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:149](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L149)

Override a tile’s base asset, terrain, elevation, connectivity, and tags.

#### Parameters

[Section titled “Parameters”](#parameters-28)

##### options

[Section titled “options”](#options-26)

[`TileAssetOptions`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/)

#### Returns

[Section titled “Returns”](#returns-29)

`this`

# advanceAllGameboardQuests

> **advanceAllGameboardQuests**(`world`, `options?`): [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:319](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L319)

Advance every quest in the world.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### options?

[Section titled “options?”](#options)

[`AdvanceGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardquestoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

# advanceGameboardMovement

> **advanceGameboardMovement**(`world`, `placement`, `options?`): [`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:395](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L395)

Advance one movement agent by one or more path steps.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### placement

[Section titled “placement”](#placement)

`string` | `Entity`

### options?

[Section titled “options?”](#options)

[`AdvanceGameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardmovementoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)

# advanceGameboardPatrol

> **advanceGameboardPatrol**(`world`, `placement`, `options?`): [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:223](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L223)

Advance one patrol agent through waiting, movement requests, and route completion.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### placement

[Section titled “placement”](#placement)

`string` | `Entity`

### options?

[Section titled “options?”](#options)

[`AdvanceGameboardPatrolOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardpatroloptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)

# advanceGameboardQuest

> **advanceGameboardQuest**(`world`, `quest`, `options?`): [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:266](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L266)

Advance one quest and update objective progress.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### quest

[Section titled “quest”](#quest)

`string` | `Entity`

### options?

[Section titled “options?”](#options)

[`AdvanceGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardquestoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

# analyzeGameboardPieceRegistry

> **analyzeGameboardPieceRegistry**(`registry`, `options?`): [`GameboardPieceRegistryAnalysis`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryanalysis/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:461](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L461)

Analyze piece counts, tags, local-only assets, and optional compatibility checks for a registry.

## Parameters

[Section titled “Parameters”](#parameters)

### registry

[Section titled “registry”](#registry)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

### options?

[Section titled “options?”](#options)

[`AnalyzeGameboardPieceRegistryOptions`](/declarative-hex-worlds/reference/index/interfaces/analyzegameboardpieceregistryoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPieceRegistryAnalysis`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryanalysis/)

# applyGameboardRecipeGeneration

> **applyGameboardRecipeGeneration**(`plan`, `generation`): [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe-generation.ts:27](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe-generation.ts#L27)

Run seeded recipe generation over a built plan and return the projected result. Builds a koota world, spawns the generation’s layout-fill, projects back. When the generation declares no fill rules, returns the plan unchanged (no world).

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### generation

[Section titled “generation”](#generation)

[`GameboardRecipeGeneration`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipegeneration/) | `undefined`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

# areGameboardActorsHostile

> **areGameboardActorsHostile**(`left`, `right`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:1039](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L1039)

Return whether two actors should be considered hostile to each other.

## Parameters

[Section titled “Parameters”](#parameters)

### left

[Section titled “left”](#left)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/) | { `actorId`: `string`; `blocksMovement`: `boolean`; `faction`: `string` | `undefined`; `hostile`: `boolean`; `interactive`: `boolean`; `kind`: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/); `metadata`: `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>; `tags`: `string`\[]; `team`: `string` | `undefined`; } | `undefined`

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)

***

#### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `actorId`: `string`; `blocksMovement`: `boolean`; `faction`: `string` | `undefined`; `hostile`: `boolean`; `interactive`: `boolean`; `kind`: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/); `metadata`: `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>; `tags`: `string`\[]; `team`: `string` | `undefined`; }

##### actorId

[Section titled “actorId”](#actorid)

`string` = `''`

Stable gameplay actor id.

##### blocksMovement

[Section titled “blocksMovement”](#blocksmovement)

`boolean` = `false`

Whether this actor blocks movement.

##### faction

[Section titled “faction”](#faction)

`string` | `undefined` = `...`

Optional faction identifier.

##### hostile

[Section titled “hostile”](#hostile)

`boolean` = `false`

Whether this actor is generally hostile.

##### interactive

[Section titled “interactive”](#interactive)

`boolean` = `false`

Whether this actor should be treated as an interaction target.

##### kind

[Section titled “kind”](#kind)

[`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/) = `...`

Actor role used by collision, targeting, commands, and fixtures.

##### metadata

[Section titled “metadata”](#metadata)

`Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)> = `...`

Serializable actor metadata.

##### tags

[Section titled “tags”](#tags)

`string`\[] = `...`

Free-form actor tags.

##### team

[Section titled “team”](#team)

`string` | `undefined` = `...`

Optional team identifier.

***

`undefined`

### right

[Section titled “right”](#right)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/) | { `actorId`: `string`; `blocksMovement`: `boolean`; `faction`: `string` | `undefined`; `hostile`: `boolean`; `interactive`: `boolean`; `kind`: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/); `metadata`: `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>; `tags`: `string`\[]; `team`: `string` | `undefined`; } | `undefined`

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)

***

#### Type Literal

[Section titled “Type Literal”](#type-literal-1)

{ `actorId`: `string`; `blocksMovement`: `boolean`; `faction`: `string` | `undefined`; `hostile`: `boolean`; `interactive`: `boolean`; `kind`: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/); `metadata`: `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>; `tags`: `string`\[]; `team`: `string` | `undefined`; }

##### actorId

[Section titled “actorId”](#actorid-1)

`string` = `''`

Stable gameplay actor id.

##### blocksMovement

[Section titled “blocksMovement”](#blocksmovement-1)

`boolean` = `false`

Whether this actor blocks movement.

##### faction

[Section titled “faction”](#faction-1)

`string` | `undefined` = `...`

Optional faction identifier.

##### hostile

[Section titled “hostile”](#hostile-1)

`boolean` = `false`

Whether this actor is generally hostile.

##### interactive

[Section titled “interactive”](#interactive-1)

`boolean` = `false`

Whether this actor should be treated as an interaction target.

##### kind

[Section titled “kind”](#kind-1)

[`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/) = `...`

Actor role used by collision, targeting, commands, and fixtures.

##### metadata

[Section titled “metadata”](#metadata-1)

`Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)> = `...`

Serializable actor metadata.

##### tags

[Section titled “tags”](#tags-1)

`string`\[] = `...`

Free-form actor tags.

##### team

[Section titled “team”](#team-1)

`string` | `undefined` = `...`

Optional team identifier.

***

`undefined`

## Returns

[Section titled “Returns”](#returns)

`boolean`

# assertCoverableCoastMask

> **assertCoverableCoastMask**(`edges`, `context?`): `void`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:281](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L281)

Assert that `edges` form a coverable coast mask, throwing a clear author-time error otherwise. Called by `GameboardBuilder.setCoastEdges` so a bad mask fails at the authoring call — naming the tile + the offending mask — rather than deep in projection with an opaque “no coast variant covers …” runtime error.

## Parameters

[Section titled “Parameters”](#parameters)

### edges

[Section titled “edges”](#edges)

[`HexEdgeInput`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeinput/)

### context?

[Section titled “context?”](#context)

#### tileKey?

[Section titled “tileKey?”](#tilekey)

`string`

## Returns

[Section titled “Returns”](#returns)

`void`

# assertGameboardScenarioSimulationExpectations

> **assertGameboardScenarioSimulationExpectations**(`report`, `expectations?`): `void`

Defined in: [packages/declarative-hex-worlds/src/simulation/assertions.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/assertions.ts#L65)

Throws when a simulation report does not satisfy its expectations.

## Parameters

[Section titled “Parameters”](#parameters)

### report

[Section titled “report”](#report)

[`GameboardScenarioSimulationReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationreport/)

### expectations?

[Section titled “expectations?”](#expectations)

[`GameboardScenarioSimulationExpectations`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationexpectations/) | `undefined`

## Returns

[Section titled “Returns”](#returns)

`void`

# assetIdFromPath

> **assetIdFromPath**(`path`): `string`

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:80](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L80)

Derive a stable asset id from a path: the basename without extension, slug-safe. Returns `''` when the basename has no stem (e.g. a dotfile like `.glb`, whose only `.` starts the name) — the scanner treats an empty id as unclassifiable and routes it to `skipped` rather than emitting an id the spec schema rejects.

## Parameters

[Section titled “Parameters”](#parameters)

### path

[Section titled “path”](#path)

`string`

## Returns

[Section titled “Returns”](#returns)

`string`

# bindingTargetsMesh

> **bindingTargetsMesh**(`binding`, `meshName`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts:69](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts#L69)

True if a mesh/material name is a target of the binding (a binding with no targets matches all).

## Parameters

[Section titled “Parameters”](#parameters)

### binding

[Section titled “binding”](#binding)

[`TextureBinding`](/declarative-hex-worlds/reference/index/interfaces/texturebinding/)

### meshName

[Section titled “meshName”](#meshname)

`string`

## Returns

[Section titled “Returns”](#returns)

`boolean`

# buildAssetSourceSpec

> **buildAssetSourceSpec**(`files`, `options`): `object`

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:246](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L246)

Build a candidate `AssetSourceSpec` from a scan. Non-tileset assets are emitted as-is; tilesets are given a placeholder grid (the CLI overwrites it with author input — a placeholder keeps the spec shape valid for preview). Returns the spec plus the scan’s skipped/needs-grid info so the caller can surface it.

## Parameters

[Section titled “Parameters”](#parameters)

### files

[Section titled “files”](#files)

readonly [`ScannedFile`](/declarative-hex-worlds/reference/index/interfaces/scannedfile/)\[]

### options

[Section titled “options”](#options)

#### assetRoot

[Section titled “assetRoot”](#assetroot)

`string`

#### name

[Section titled “name”](#name)

`string`

#### resolveTilesetGrid?

[Section titled “resolveTilesetGrid?”](#resolvetilesetgrid)

(`asset`) => { `cellHeight`: `number`; `cellWidth`: `number`; `cols`: `number`; `rows`: `number`; } | `undefined`

Per-tileset grid resolver (the CLI supplies this — it reads the PNG bytes and derives the grid via `readPngDimensions` + `inferTilesetGrid`, keeping this function pure of fs/image-decode). Return `undefined` to fall back to `tilesetGrid`. When BOTH are absent a tileset keeps the placeholder grid and is reported in `scan.tilesetsNeedingGrid` so the author can fix it.

#### tilesetGrid?

[Section titled “tilesetGrid?”](#tilesetgrid)

{ `cellHeight`: `number`; `cellWidth`: `number`; `cols`: `number`; `rows`: `number`; }

Fallback grid for tilesets when no per-tileset grid is resolved.

#### tilesetGrid.cellHeight

[Section titled “tilesetGrid.cellHeight”](#tilesetgridcellheight)

`number`

#### tilesetGrid.cellWidth

[Section titled “tilesetGrid.cellWidth”](#tilesetgridcellwidth)

`number`

#### tilesetGrid.cols

[Section titled “tilesetGrid.cols”](#tilesetgridcols)

`number`

#### tilesetGrid.rows

[Section titled “tilesetGrid.rows”](#tilesetgridrows)

`number`

## Returns

[Section titled “Returns”](#returns)

`object`

### scan

[Section titled “scan”](#scan)

> **scan**: [`ScanResult`](/declarative-hex-worlds/reference/index/interfaces/scanresult/)

### spec

[Section titled “spec”](#spec)

> **spec**: `object`

#### spec.assetRoot

[Section titled “spec.assetRoot”](#specassetroot)

> **assetRoot**: `string`

Root directory the asset paths are relative to (e.g. “public/assets”).

#### spec.assets

[Section titled “spec.assets”](#specassets)

> **assets**: ({ `biome`: `string`; `edgeMask?`: `number`; `format`: `"png"` | `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"tile"`; } | { `biome?`: `string`; `format`: `"png"`; `grid`: { `cellHeight`: `number`; `cellWidth`: `number`; `cols`: `number`; `rows`: `number`; }; `id`: `string`; `path`: `string`; `role`: `"tileset"`; `transition?`: { `edgeCells`: `Record`<`string`, `number`>; }; } | { `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"png"`; `id`: `string`; `path`: `string`; `role`: `"sprite"`; } | { `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"model"`; })\[]

Ordered asset records.

#### spec.name

[Section titled “spec.name”](#specname)

> **name**: `string`

Human-readable source name (e.g. “kaykit-free”, “my-tileset-pack”).

#### spec.specVersion

[Section titled “spec.specVersion”](#specspecversion)

> **specVersion**: `1`

Spec format version (this schema is v1).

# canOccupyGameboardPlacement

> **canOccupyGameboardPlacement**(`world`, `options`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:779](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L779)

Return whether a proposed placement footprint can occupy its target tiles.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### options

[Section titled “options”](#options)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/)

## Returns

[Section titled “Returns”](#returns)

`boolean`

# cellRect

> **cellRect**(`grid`, `cellIndex`): [`CellRect`](/declarative-hex-worlds/reference/index/interfaces/cellrect/)

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset.ts:108](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset.ts#L108)

The row-major pixel rect of a 0-based cell index within a grid.

## Parameters

[Section titled “Parameters”](#parameters)

### grid

[Section titled “grid”](#grid)

#### cellHeight

[Section titled “cellHeight”](#cellheight)

`number` = `...`

#### cellWidth

[Section titled “cellWidth”](#cellwidth)

`number` = `...`

#### cols

[Section titled “cols”](#cols)

`number` = `...`

#### rows

[Section titled “rows”](#rows)

`number` = `...`

### cellIndex

[Section titled “cellIndex”](#cellindex)

`number`

## Returns

[Section titled “Returns”](#returns)

[`CellRect`](/declarative-hex-worlds/reference/index/interfaces/cellrect/)

# classifierMetadata

> **classifierMetadata**(`tags`): `Record`<`string`, `boolean`>

Defined in: [packages/declarative-hex-worlds/src/classifiers/classifiers.ts:165](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/classifiers/classifiers.ts#L165)

A metadata patch that flags the given classifiers on a placement (all `true`).

## Parameters

[Section titled “Parameters”](#parameters)

### tags

[Section titled “tags”](#tags)

readonly [`ClassifierTag`](/declarative-hex-worlds/reference/index/type-aliases/classifiertag/)\[]

## Returns

[Section titled “Returns”](#returns)

`Record`<`string`, `boolean`>

# classifierMetadataKey

> **classifierMetadataKey**(`tag`): `string`

Defined in: [packages/declarative-hex-worlds/src/classifiers/classifiers.ts:160](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/classifiers/classifiers.ts#L160)

The metadata KEY a classifier is stored under on a placement. Placement metadata values are `string | number | boolean | null`, so each classifier is a boolean flag (`classifier:enemy` → true) rather than an array — this keeps classifiers queryable through the placement metadata that survives projection into the koota world.

## Parameters

[Section titled “Parameters”](#parameters)

### tag

[Section titled “tag”](#tag)

[`ClassifierTag`](/declarative-hex-worlds/reference/index/type-aliases/classifiertag/)

## Returns

[Section titled “Returns”](#returns)

`string`

# classifierTagsOf

> **classifierTagsOf**(`metadata`): readonly [`ClassifierTag`](/declarative-hex-worlds/reference/index/type-aliases/classifiertag/)\[]

Defined in: [packages/declarative-hex-worlds/src/classifiers/classifiers.ts:176](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/classifiers/classifiers.ts#L176)

The classifier tags flagged in a placement’s metadata (keys prefixed + truthy).

## Parameters

[Section titled “Parameters”](#parameters)

### metadata

[Section titled “metadata”](#metadata)

`Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

## Returns

[Section titled “Returns”](#returns)

readonly [`ClassifierTag`](/declarative-hex-worlds/reference/index/type-aliases/classifiertag/)\[]

# classifyGameboardPlacement

> **classifyGameboardPlacement**(`world`, `actorOrPlacement`): [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:1029](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L1029)

Return the gameplay actor kind for an actor or placement, when registered.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### actorOrPlacement

[Section titled “actorOrPlacement”](#actororplacement)

`string` | `Entity`

## Returns

[Section titled “Returns”](#returns)

[`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/) | `undefined`

# classifyPlacement

> **classifyPlacement**(`placement`, `classifiers?`): readonly [`ClassifierTag`](/declarative-hex-worlds/reference/index/type-aliases/classifiertag/)\[]

Defined in: [packages/declarative-hex-worlds/src/classifiers/classifiers.ts:137](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/classifiers/classifiers.ts#L137)

Union of the classifier tags every classifier assigns to a placement (order-stable, deduped).

## Parameters

[Section titled “Parameters”](#parameters)

### placement

[Section titled “placement”](#placement)

[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

### classifiers?

[Section titled “classifiers?”](#classifiers)

readonly [`PlacementClassifier`](/declarative-hex-worlds/reference/index/type-aliases/placementclassifier/)\[] = `DEFAULT_PLACEMENT_CLASSIFIERS`

## Returns

[Section titled “Returns”](#returns)

readonly [`ClassifierTag`](/declarative-hex-worlds/reference/index/type-aliases/classifiertag/)\[]

# clearGameboardMovement

> **clearGameboardMovement**(`world`, `placement`): `Entity`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:426](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L426)

Clear active path state for one movement agent.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### placement

[Section titled “placement”](#placement)

`string` | `Entity`

## Returns

[Section titled “Returns”](#returns)

`Entity`

# clearGameboardPatrolAgent

> **clearGameboardPatrolAgent**(`world`, `placement`): `Entity`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:204](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L204)

Remove patrol state from a placement or actor.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### placement

[Section titled “placement”](#placement)

`string` | `Entity`

## Returns

[Section titled “Returns”](#returns)

`Entity`

# clearGameboardWorld

> **clearGameboardWorld**(`world`): `void`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:601](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L601)

Remove all gameboard tiles, placements, and board metadata from the world.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

## Returns

[Section titled “Returns”](#returns)

`void`

# combineSources

> **combineSources**(`sources`): [`AssetSource`](/declarative-hex-worlds/reference/index/interfaces/assetsource/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:167](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L167)

Compose sources into one first-match `AssetSource`: the first source to resolve a placement (or edge) wins. Returns the single source directly, or `undefined` for an empty list. Renderer-neutral, so it lives in the core alongside the `AssetSource` contract (a binding then registers the composite). Re-exported from `declarative-hex-worlds/react-elements` for back-compat.

## Parameters

[Section titled “Parameters”](#parameters)

### sources

[Section titled “sources”](#sources)

readonly [`AssetSource`](/declarative-hex-worlds/reference/index/interfaces/assetsource/)\[]

## Returns

[Section titled “Returns”](#returns)

[`AssetSource`](/declarative-hex-worlds/reference/index/interfaces/assetsource/) | `undefined`

# computeBoardBounds

> **computeBoardBounds**(`tiles`): [`BoardBounds`](/declarative-hex-worlds/reference/index/interfaces/boardbounds/)

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:91](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L91)

Compute the world-space bounds of a board from its tiles (their world positions at their elevation). An empty board yields a unit box centered at the origin so a binding never divides by zero.

## Parameters

[Section titled “Parameters”](#parameters)

### tiles

[Section titled “tiles”](#tiles)

readonly [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)\[]

## Returns

[Section titled “Returns”](#returns)

[`BoardBounds`](/declarative-hex-worlds/reference/index/interfaces/boardbounds/)

# computeCameraFraming

> **computeCameraFraming**(`bounds`, `state?`): [`CameraFraming`](/declarative-hex-worlds/reference/index/interfaces/cameraframing/)

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:151](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L151)

Compute a renderer-neutral camera framing for a board’s bounds + a requested view. The eye sits along the angle’s direction at a distance chosen so the board fits (`frame-board`, with padding) or fills (`fill-viewport`) the view; the target is the board center. `orthoHalfHeight` sizes an orthographic box; `fov`/`distance` size a perspective one.

## Parameters

[Section titled “Parameters”](#parameters)

### bounds

[Section titled “bounds”](#bounds)

[`BoardBounds`](/declarative-hex-worlds/reference/index/interfaces/boardbounds/)

### state?

[Section titled “state?”](#state)

[`CameraState`](/declarative-hex-worlds/reference/index/interfaces/camerastate/) = `DEFAULT_CAMERA_STATE`

## Returns

[Section titled “Returns”](#returns)

[`CameraFraming`](/declarative-hex-worlds/reference/index/interfaces/cameraframing/)

# containsHex

> **containsHex**(`shape`, `coordinates`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:154](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L154)

Checks whether an axial coordinate is inside a supported board shape.

## Parameters

[Section titled “Parameters”](#parameters)

### shape

[Section titled “shape”](#shape)

[`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

### coordinates

[Section titled “coordinates”](#coordinates)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

## Returns

[Section titled “Returns”](#returns)

`boolean`

# coordinatesForShape

> **coordinatesForShape**(`shape`): [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L134)

Lists all axial coordinates inside a supported board shape.

## Parameters

[Section titled “Parameters”](#parameters)

### shape

[Section titled “shape”](#shape)

[`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

## Returns

[Section titled “Returns”](#returns)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

# createGameboardActorNavigationProfile

> **createGameboardActorNavigationProfile**(`world`, `actor`, `options?`): [`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:1109](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L1109)

Create a navigation profile that rejects tiles blocked for a specific actor.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### actor

[Section titled “actor”](#actor)

`string` | `Entity`

### options?

[Section titled “options?”](#options)

[`GameboardActorNavigationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactornavigationoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

# createGameboardBuilder

> **createGameboardBuilder**(`options`): [`GameboardBuilder`](/declarative-hex-worlds/reference/index/classes/gameboardbuilder/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:831](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L831)

Create a fluent gameboard builder.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardBuilder`](/declarative-hex-worlds/reference/index/classes/gameboardbuilder/)

# createGameboardInteractionHandlerPreset

> **createGameboardInteractionHandlerPreset**(`preset`, `options?`): readonly [`GameboardInteractionHandler`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandler/)\[]

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:616](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L616)

Expands a named handler preset into concrete interaction handlers.

## Parameters

[Section titled “Parameters”](#parameters)

### preset

[Section titled “preset”](#preset)

`"remove-target-actor"` | `"remove-target-placement"` | `"mark-target-interacted"` | `"default-rpg"`

### options?

[Section titled “options?”](#options)

[`CreateGameboardInteractionHandlerPresetOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardinteractionhandlerpresetoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

readonly [`GameboardInteractionHandler`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandler/)\[]

# createGameboardInteropSnapshot

> **createGameboardInteropSnapshot**(`plan`, `options?`): [`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:624](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L624)

Create an interop snapshot from a generated board plan.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### options?

[Section titled “options?”](#options)

[`GameboardInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

# createGameboardInteropSnapshotIndex

> **createGameboardInteropSnapshotIndex**(`snapshot`): [`GameboardInteropSnapshotIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshotindex/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:840](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L840)

Create lookup indexes for an interop snapshot.

## Parameters

[Section titled “Parameters”](#parameters)

### snapshot

[Section titled “snapshot”](#snapshot)

[`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardInteropSnapshotIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshotindex/)

# createGameboardLayoutFillRuleFromPiece

> **createGameboardLayoutFillRuleFromPiece**(`piece`, `options?`): [`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:553](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L553)

Convert one piece declaration into a layout fill rule.

## Parameters

[Section titled “Parameters”](#parameters)

### piece

[Section titled “piece”](#piece)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

### options?

[Section titled “options?”](#options)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)

# createGameboardLayoutFillRuleFromPieces

> **createGameboardLayoutFillRuleFromPieces**(`pieces`, `options?`): [`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:582](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L582)

Convert a compatible collection of pieces into one pooled layout fill rule.

## Parameters

[Section titled “Parameters”](#parameters)

### pieces

[Section titled “pieces”](#pieces)

readonly [`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)\[]

### options?

[Section titled “options?”](#options)

[`GameboardPieceCollectionLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiececollectionlayoutruleoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)

# createGameboardLayoutFillRulesFromRegistry

> **createGameboardLayoutFillRulesFromRegistry**(`registry`, `options?`): [`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:625](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L625)

Create one fill rule for each selected piece in a registry.

## Parameters

[Section titled “Parameters”](#parameters)

### registry

[Section titled “registry”](#registry)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

### options?

[Section titled “options?”](#options)

[`GameboardPieceRegistryFillRulesOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryfillrulesoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

# createGameboardLayoutPlacementOptionsFromPiece

> **createGameboardLayoutPlacementOptionsFromPiece**(`piece`, `options?`): [`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:642](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L642)

Convert one piece declaration into direct layout placement options.

## Parameters

[Section titled “Parameters”](#parameters)

### piece

[Section titled “piece”](#piece)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

### options?

[Section titled “options?”](#options)

[`GameboardPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/)

# createGameboardLayoutPlacementsFromPiece

> **createGameboardLayoutPlacementsFromPiece**(`plan`, `piece`, `options?`): [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:668](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L668)

Create placement spawn options for one piece on a plan.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### piece

[Section titled “piece”](#piece)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

### options?

[Section titled “options?”](#options)

[`GameboardPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

# createGameboardMovementNavigation

> **createGameboardMovementNavigation**(`world`, `placement`, `options?`): [`GameboardNavigation`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigation/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:309](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L309)

Create navigation for one movement agent, ignoring the agent’s own placement.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### placement

[Section titled “placement”](#placement)

`string` | `Entity`

### options?

[Section titled “options?”](#options)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardNavigation`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigation/)

# createGameboardPatrolSimulationScript

> **createGameboardPatrolSimulationScript**(`options`): [`GameboardPatrolSimulationScriptPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationscriptplan/)

Defined in: [packages/declarative-hex-worlds/src/simulation/engine.ts:204](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/engine.ts#L204)

Converts patrol routes into a complete simulation script.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`CreateGameboardPatrolSimulationScriptOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardpatrolsimulationscriptoptions/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardPatrolSimulationScriptPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationscriptplan/)

# createGameboardPatrolSimulationSteps

> **createGameboardPatrolSimulationSteps**(`options`): [`GameboardPatrolSimulationStepsPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationstepsplan/)

Defined in: [packages/declarative-hex-worlds/src/simulation/engine.ts:120](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/engine.ts#L120)

Converts planned patrol routes into executable command steps.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`CreateGameboardPatrolSimulationStepsOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardpatrolsimulationstepsoptions/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardPatrolSimulationStepsPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationstepsplan/)

# createGameboardPieceRegistry

> **createGameboardPieceRegistry**(`declarations`): [`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:430](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L430)

Create a normalized piece registry and lookup indexes.

## Parameters

[Section titled “Parameters”](#parameters)

### declarations

[Section titled “declarations”](#declarations)

readonly [`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/)\[]

## Returns

[Section titled “Returns”](#returns)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

# createGameboardPieceRegistryFromCompatibilityReports

> **createGameboardPieceRegistryFromCompatibilityReports**(`reports`, `options?`): [`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:420](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L420)

Create a piece registry from compatibility reports.

## Parameters

[Section titled “Parameters”](#parameters)

### reports

[Section titled “reports”](#reports)

readonly [`ExternalAssetCompatibilityReport`](/declarative-hex-worlds/reference/interop/compatibility/interfaces/externalassetcompatibilityreport/)\[]

### options?

[Section titled “options?”](#options)

[`GameboardPieceCompatibilityBatchOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiececompatibilitybatchoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

# createGameboardPieceSourceUrlMap

> **createGameboardPieceSourceUrlMap**(`registry`, `options?`): `Readonly`<`Record`<`string`, `string`>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:724](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L724)

Create an asset-id-to-source-URL map for every piece with resolvable source metadata.

## Parameters

[Section titled “Parameters”](#parameters)

### registry

[Section titled “registry”](#registry)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

### options?

[Section titled “options?”](#options)

[`GameboardPieceSourceUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecesourceurloptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

`Readonly`<`Record`<`string`, `string`>>

# createGameboardPlacementAssetUrlResolver

> **createGameboardPlacementAssetUrlResolver**(`options?`): [`GameboardPlacementAssetUrlResolver`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementasseturlresolver/)

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:104](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L104)

Creates a reusable placement-to-model URL resolver.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`GameboardPlacementAssetUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlacementAssetUrlResolver`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementasseturlresolver/)

# createGameboardPlan

> **createGameboardPlan**(`options`, `configure?`): [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:839](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L839)

Create a complete gameboard plan, optionally configuring it through a builder callback before build.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/)

### configure?

[Section titled “configure?”](#configure)

(`builder`) => `void`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

# createGameboardPlanFromTiles

> **createGameboardPlanFromTiles**(`options`): [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/terrain.ts:97](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/terrain.ts#L97)

Create a complete plan from explicit tiles and custom placements, adding the derived terrain and connectivity placements used by renderers.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`GameboardPlanFromTilesOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanfromtilesoptions/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

# createGameboardQuest

> **createGameboardQuest**(`definition`): [`GameboardQuestDefinition`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestdefinition/)

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:174](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L174)

Normalize a quest definition into a serializable copy.

## Parameters

[Section titled “Parameters”](#parameters)

### definition

[Section titled “definition”](#definition)

[`GameboardQuestDefinition`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestdefinition/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardQuestDefinition`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestdefinition/)

# createGameboardRuntime

> **createGameboardRuntime**(`input`): [`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:671](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L671)

Creates a runtime facade from an existing world, a serializable plan, or explicit runtime options.

## Parameters

[Section titled “Parameters”](#parameters)

### input

[Section titled “input”](#input)

[`CreateGameboardRuntimeInput`](/declarative-hex-worlds/reference/index/type-aliases/creategameboardruntimeinput/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/)

# createGameboardRuntimeFromRecipe

> **createGameboardRuntimeFromRecipe**(`recipe`, `overrides?`): [`GameboardRecipeGameRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardrecipegameruntime/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:680](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L680)

Compiles a recipe into a live runtime while preserving recipe-local layout archetypes and piece registry helpers.

## Parameters

[Section titled “Parameters”](#parameters)

### recipe

[Section titled “recipe”](#recipe)

[`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

### overrides?

[Section titled “overrides?”](#overrides)

[`GameboardRecipePlanOptionsOverride`](/declarative-hex-worlds/reference/scenario/recipe/type-aliases/gameboardrecipeplanoptionsoverride/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardRecipeGameRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardrecipegameruntime/)

# createGameboardRuntimeFromScenario

> **createGameboardRuntimeFromScenario**(`scenario`, `overrides?`): [`GameboardScenarioGameRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariogameruntime/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:701](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L701)

Compiles a scenario into a live runtime while preserving actor/quest indexes, scenario interop helpers, and scenario-local piece source URL helpers.

## Parameters

[Section titled “Parameters”](#parameters)

### scenario

[Section titled “scenario”](#scenario)

[`GameboardScenario`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenario/)

### overrides?

[Section titled “overrides?”](#overrides)

[`GameboardRecipePlanOptionsOverride`](/declarative-hex-worlds/reference/scenario/recipe/type-aliases/gameboardrecipeplanoptionsoverride/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardScenarioGameRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariogameruntime/)

# createGameboardRuntimeInteropSnapshot

> **createGameboardRuntimeInteropSnapshot**(`state`, `options?`): [`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:803](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L803)

Create an interop snapshot from live runtime state.

## Parameters

[Section titled “Parameters”](#parameters)

### state

[Section titled “state”](#state)

[`GameboardRuntimeInteropState`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimeinteropstate/)

### options?

[Section titled “options?”](#options)

[`GameboardRuntimeInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimeinteropoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

# createGameboardScenario

> **createGameboardScenario**(`id`, `board`, `options?`): [`GameboardScenario`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenario/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:334](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L334)

Creates a cloned, schema-tagged gameboard scenario.

## Parameters

[Section titled “Parameters”](#parameters)

### id

[Section titled “id”](#id)

`string`

### board

[Section titled “board”](#board)

[`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

### options?

[Section titled “options?”](#options)

[`CreateGameboardScenarioOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardscenariooptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardScenario`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenario/)

# createGameboardScenarioInteropSnapshot

> **createGameboardScenarioInteropSnapshot**(`scenario`, `options?`): [`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:663](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L663)

Create an interop snapshot from a scenario recipe, including optional actors, quests, spawn groups, and patrol routes.

## Parameters

[Section titled “Parameters”](#parameters)

### scenario

[Section titled “scenario”](#scenario)

[`GameboardScenario`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenario/)

### options?

[Section titled “options?”](#options)

[`GameboardScenarioInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariointeropoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

# createGameboardScenarioSimulationReport

> **createGameboardScenarioSimulationReport**(`result`, `expectations?`): [`GameboardScenarioSimulationReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationreport/)

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:263](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L263)

Creates a serializable report from an in-memory simulation result.

## Parameters

[Section titled “Parameters”](#parameters)

### result

[Section titled “result”](#result)

[`GameboardScenarioSimulationResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationresult/)

### expectations?

[Section titled “expectations?”](#expectations)

[`GameboardScenarioSimulationExpectations`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationexpectations/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardScenarioSimulationReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationreport/)

# createGameboardSimulationInteropSnapshot

> **createGameboardSimulationInteropSnapshot**(`report`, `options?`): [`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:755](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L755)

Create an interop snapshot from a completed scenario simulation report.

## Parameters

[Section titled “Parameters”](#parameters)

### report

[Section titled “report”](#report)

[`GameboardScenarioSimulationReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationreport/)

### options?

[Section titled “options?”](#options)

[`GameboardSimulationInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardsimulationinteropoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

# createGameboardWorld

> **createGameboardWorld**(`plan?`): `World`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:398](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L398)

Create a Koota world ready for gameboard systems, optionally preloaded with a complete board plan.

## Parameters

[Section titled “Parameters”](#parameters)

### plan?

[Section titled “plan?”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

## Returns

[Section titled “Returns”](#returns)

`World`

# createGameboardWorldFromScenario

> **createGameboardWorldFromScenario**(`scenario`, `overrides?`): [`GameboardScenarioRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenarioruntime/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:642](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L642)

Compiles a scenario and spawns its board, actors, agents, and quests into a Koota world.

## Parameters

[Section titled “Parameters”](#parameters)

### scenario

[Section titled “scenario”](#scenario)

[`GameboardScenario`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenario/)

### overrides?

[Section titled “overrides?”](#overrides)

[`GameboardRecipePlanOptionsOverride`](/declarative-hex-worlds/reference/scenario/recipe/type-aliases/gameboardrecipeplanoptionsoverride/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardScenarioRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenarioruntime/)

# createGltfPackSource

> **createGltfPackSource**(`options?`): [`AssetSource`](/declarative-hex-worlds/reference/index/interfaces/assetsource/)

Defined in: [packages/declarative-hex-worlds/src/asset-source/gltf-pack.ts:46](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/gltf-pack.ts#L46)

Create a `gltf-pack` AssetSource. Resolves a placement to a `{ type: 'gltf' }` request via the existing URL resolver + placement transform, or `undefined` when no URL resolves (letting the caller fall through).

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`GameboardPlacementAssetUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`AssetSource`](/declarative-hex-worlds/reference/index/interfaces/assetsource/)

# createHarborBoard

> **createHarborBoard**(`options?`): [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/gameboard.ts:851](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/gameboard.ts#L851)

Create the built-in medieval harbor sample board used by examples and tests.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`HarborBoardOptions`](/declarative-hex-worlds/reference/index/interfaces/harborboardoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

# createInMemoryGameboardEcs

> **createInMemoryGameboardEcs**(): [`InMemoryGameboardEcs`](/declarative-hex-worlds/reference/index/interfaces/inmemorygameboardecs/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:925](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L925)

Create a small in-memory ECS adapter for examples and integration tests.

## Returns

[Section titled “Returns”](#returns)

[`InMemoryGameboardEcs`](/declarative-hex-worlds/reference/index/interfaces/inmemorygameboardecs/)

# createMarkTargetActorInteractedHandler

> **createMarkTargetActorInteractedHandler**(`options?`): [`GameboardInteractionHandler`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandler/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:570](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L570)

Creates a handler that marks the target actor as interacted in metadata.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`MarkTargetActorInteractedHandlerOptions`](/declarative-hex-worlds/reference/index/interfaces/marktargetactorinteractedhandleroptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardInteractionHandler`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandler/)

# createRemoveTargetActorHandler

> **createRemoveTargetActorHandler**(`options?`): [`GameboardInteractionHandler`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandler/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:480](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L480)

Creates a handler that removes the target actor for accepted command kinds.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`RemoveTargetActorHandlerOptions`](/declarative-hex-worlds/reference/index/interfaces/removetargetactorhandleroptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardInteractionHandler`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandler/)

# createRemoveTargetPlacementHandler

> **createRemoveTargetPlacementHandler**(`options?`): [`GameboardInteractionHandler`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandler/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:528](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L528)

Creates a handler that removes a target placement for accepted command kinds.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`RemoveTargetPlacementHandlerOptions`](/declarative-hex-worlds/reference/index/interfaces/removetargetplacementhandleroptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardInteractionHandler`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandler/)

# createSeededGameboardDensityFillRules

> **createSeededGameboardDensityFillRules**(`density`, `context?`): [`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:388](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L388)

Expands built-in density preset options into concrete layout fill rules.

## Parameters

[Section titled “Parameters”](#parameters)

### density

[Section titled “density”](#density)

[`SeededGameboardLayoutDensityOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardlayoutdensityoptions/) | `undefined`

### context?

[Section titled “context?”](#context)

[`SeededGameboardDensityContext`](/declarative-hex-worlds/reference/index/interfaces/seededgameboarddensitycontext/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

# createSeededGameboardPieceFillRules

> **createSeededGameboardPieceFillRules**(`registry`, `fills`): [`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:462](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L462)

Expands registered piece fill options into concrete layout fill rules.

## Parameters

[Section titled “Parameters”](#parameters)

### registry

[Section titled “registry”](#registry)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/) | `undefined`

### fills

[Section titled “fills”](#fills)

readonly [`SeededGameboardPieceFillOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefilloptions/)\[] | `undefined`

## Returns

[Section titled “Returns”](#returns)

[`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

# createSeededGameboardPlan

> **createSeededGameboardPlan**(`options?`): [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:211](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L211)

Creates a deterministic generated board with terrain, roads, rivers, structures, and fills.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`SeededGameboardOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

# createSeededGameboardWorld

> **createSeededGameboardWorld**(`options?`): `World`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:383](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L383)

Creates a Koota world from a deterministic generated board.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`SeededGameboardOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

`World`

# createSourceFromSpec

> **createSourceFromSpec**(`spec`, `options?`): [`AssetSource`](/declarative-hex-worlds/reference/index/interfaces/assetsource/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/asset-source/spec-source.ts:89](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/spec-source.ts#L89)

Create a live `AssetSource` from a validated `AssetSourceSpec`. Composes a tileset source (from tileset-role assets) and a gltf-pack source (from model + glb/gltf tile assets) first-match. Sprite-role assets are carried for a future sprite source; today they resolve through the gltf/tileset arms only if they match, else fall through. Returns `undefined` only when the spec yields no resolvable source.

## Parameters

[Section titled “Parameters”](#parameters)

### spec

[Section titled “spec”](#spec)

#### assetRoot

[Section titled “assetRoot”](#assetroot)

`string` = `...`

Root directory the asset paths are relative to (e.g. “public/assets”).

#### assets

[Section titled “assets”](#assets)

({ `biome`: `string`; `edgeMask?`: `number`; `format`: `"png"` | `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"tile"`; } | { `biome?`: `string`; `format`: `"png"`; `grid`: { `cellHeight`: `number`; `cellWidth`: `number`; `cols`: `number`; `rows`: `number`; }; `id`: `string`; `path`: `string`; `role`: `"tileset"`; `transition?`: { `edgeCells`: `Record`<`string`, `number`>; }; } | { `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"png"`; `id`: `string`; `path`: `string`; `role`: `"sprite"`; } | { `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"model"`; })\[] = `...`

Ordered asset records.

#### name

[Section titled “name”](#name)

`string` = `...`

Human-readable source name (e.g. “kaykit-free”, “my-tileset-pack”).

#### specVersion

[Section titled “specVersion”](#specversion)

`1` = `...`

Spec format version (this schema is v1).

### options?

[Section titled “options?”](#options)

[`CreateSourceFromSpecOptions`](/declarative-hex-worlds/reference/index/interfaces/createsourcefromspecoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`AssetSource`](/declarative-hex-worlds/reference/index/interfaces/assetsource/) | `undefined`

# createTilesetSource

> **createTilesetSource**(`options`): [`AssetSource`](/declarative-hex-worlds/reference/index/interfaces/assetsource/)

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset.ts:192](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset.ts#L192)

Create a `tileset` AssetSource over a validated manifest. `resolve` maps a placement’s biome to a fill cell (by hash of tileKey, or the first variant); `resolveEdge` maps an edge mask to a transition cell via the sheet’s edgeCells. Both return `undefined` when the biome/sheet/mask isn’t in the manifest.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`TilesetSourceOptions`](/declarative-hex-worlds/reference/index/interfaces/tilesetsourceoptions/)

## Returns

[Section titled “Returns”](#returns)

[`AssetSource`](/declarative-hex-worlds/reference/index/interfaces/assetsource/)

# declareGameboardPiece

> **declareGameboardPiece**(`input`): [`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:345](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L345)

Normalize a reusable gameboard piece declaration.

## Parameters

[Section titled “Parameters”](#parameters)

### input

[Section titled “input”](#input)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

# declareGameboardPieceFromCompatibility

> **declareGameboardPieceFromCompatibility**(`report`, `options?`): [`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:371](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L371)

Declare one piece from an external asset compatibility report.

## Parameters

[Section titled “Parameters”](#parameters)

### report

[Section titled “report”](#report)

[`ExternalAssetCompatibilityReport`](/declarative-hex-worlds/reference/interop/compatibility/interfaces/externalassetcompatibilityreport/)

### options?

[Section titled “options?”](#options)

[`GameboardPieceCompatibilityDeclarationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiececompatibilitydeclarationoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

# declareGameboardPiecesFromCompatibilityReports

> **declareGameboardPiecesFromCompatibilityReports**(`reports`, `options?`): [`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:403](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L403)

Declare pieces from multiple compatibility reports.

## Parameters

[Section titled “Parameters”](#parameters)

### reports

[Section titled “reports”](#reports)

readonly [`ExternalAssetCompatibilityReport`](/declarative-hex-worlds/reference/interop/compatibility/interfaces/externalassetcompatibilityreport/)\[]

### options?

[Section titled “options?”](#options)

[`GameboardPieceCompatibilityBatchOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiececompatibilitybatchoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)\[]

# dispatchGameboardActorTargetCommand

> **dispatchGameboardActorTargetCommand**(`world`, `options`, `commandOptions?`): [`DispatchGameboardActorTargetCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardactortargetcommandresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/command-dispatch.ts:77](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/command-dispatch.ts#L77)

Plans a command against an actor target, then dispatches it when executable.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### options

[Section titled “options”](#options)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

### commandOptions?

[Section titled “commandOptions?”](#commandoptions)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`DispatchGameboardActorTargetCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardactortargetcommandresult/)

# dispatchGameboardInteractionCommand

> **dispatchGameboardInteractionCommand**(`world`, `commandOrTarget`, `options?`): [`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/command-dispatch.ts:60](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/command-dispatch.ts#L60)

Executes one interaction command and converts the execution into system events and serializable records.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

### options?

[Section titled “options?”](#options)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

# edgeBetween

> **edgeBetween**(`from`, `to`): [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L126)

Returns the edge index from one coordinate to an adjacent coordinate.

## Parameters

[Section titled “Parameters”](#parameters)

### from

[Section titled “from”](#from)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### to

[Section titled “to”](#to)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

## Returns

[Section titled “Returns”](#returns)

[`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/) | `undefined`

# edgeMask

> **edgeMask**(`edges`): `number`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:171](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L171)

Converts an edge, edge list, or bit mask into a normalized six-bit edge mask.

## Parameters

[Section titled “Parameters”](#parameters)

### edges

[Section titled “edges”](#edges)

[`HexEdgeInput`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeinput/)

## Returns

[Section titled “Returns”](#returns)

`number`

# evaluateGameboardQuestObjective

> **evaluateGameboardQuestObjective**(`world`, `objective`, `step?`): [`GameboardQuestObjectiveEvaluation`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestobjectiveevaluation/)

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:244](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L244)

Evaluate one quest objective without mutating quest state.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### objective

[Section titled “objective”](#objective)

[`GameboardQuestObjective`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestobjective/)

### step?

[Section titled “step?”](#step)

`number` = `0`

## Returns

[Section titled “Returns”](#returns)

[`GameboardQuestObjectiveEvaluation`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestobjectiveevaluation/)

# evaluateGameboardScenarioSimulationExpectations

> **evaluateGameboardScenarioSimulationExpectations**(`report`, `expectations?`): [`GameboardScenarioSimulationExpectationFailure`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationexpectationfailure/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/assertions.ts:42](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/assertions.ts#L42)

Evaluates report expectations and returns all failures without throwing.

## Parameters

[Section titled “Parameters”](#parameters)

### report

[Section titled “report”](#report)

[`GameboardScenarioSimulationReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationreport/)

### expectations?

[Section titled “expectations?”](#expectations)

[`GameboardScenarioSimulationExpectations`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationexpectations/) | `undefined`

## Returns

[Section titled “Returns”](#returns)

[`GameboardScenarioSimulationExpectationFailure`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationexpectationfailure/)\[]

# executeGameboardInteractionCommand

> **executeGameboardInteractionCommand**(`world`, `commandOrTarget`, `options?`): [`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:426](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L426)

Executes a command by requesting movement for move commands or dispatching non-movement commands to game-supplied handlers.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

### options?

[Section titled “options?”](#options)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

# findGameboardActor

> **findGameboardActor**(`world`, `actorOrPlacement`): [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:872](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L872)

Read one actor snapshot by entity reference, placement id, or actor id.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### actorOrPlacement

[Section titled “actorOrPlacement”](#actororplacement)

`string` | `Entity`

## Returns

[Section titled “Returns”](#returns)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/) | `undefined`

# findGameboardActorEntity

> **findGameboardActorEntity**(`world`, `actorOrPlacement`): `Entity` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:853](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L853)

Find an actor entity by entity reference, placement id, or actor id.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### actorOrPlacement

[Section titled “actorOrPlacement”](#actororplacement)

`string` | `Entity`

## Returns

[Section titled “Returns”](#returns)

`Entity` | `undefined`

# findGameboardMovementPath

> **findGameboardMovementPath**(`world`, `placement`, `destination`, `options?`): [`GameboardNavigationPathResult`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationpathresult/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:323](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L323)

Find a movement path from a placement to a destination.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### placement

[Section titled “placement”](#placement)

`string` | `Entity`

### destination

[Section titled “destination”](#destination)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### options?

[Section titled “options?”](#options)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardNavigationPathResult`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationpathresult/)

# findGameboardQuest

> **findGameboardQuest**(`world`, `quest`): [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:226](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L226)

Find a quest snapshot by entity reference or quest id.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### quest

[Section titled “quest”](#quest)

`string` | `Entity`

## Returns

[Section titled “Returns”](#returns)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/) | `undefined`

# findGameboardQuestEntity

> **findGameboardQuestEntity**(`world`, `quest`): `Entity` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:216](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L216)

Find a quest entity by entity reference or quest id.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### quest

[Section titled “quest”](#quest)

`string` | `Entity`

## Returns

[Section titled “Returns”](#returns)

`Entity` | `undefined`

# findHexPath

> **findHexPath**(`start`, `goal`, `options?`): [`HexPathResult`](/declarative-hex-worlds/reference/index/interfaces/hexpathresult/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:231](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L231)

Finds a weighted shortest path across axial neighbors.

This is A\*: `costByKey` is the known g-score from `start`, the heap priority is `g + hexDistance(node, goal)`, and `closed` lets older duplicate heap entries fall out cheaply after a better route to the same key was queued. The hex-distance heuristic is admissible for the default unit-cost graph and custom costs >= 1. Callers that provide cheaper or negative step costs may still get a path, but they are opting out of the shortest-path guarantee.

## Parameters

[Section titled “Parameters”](#parameters)

### start

[Section titled “start”](#start)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### goal

[Section titled “goal”](#goal)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### options?

[Section titled “options?”](#options)

[`HexPathOptions`](/declarative-hex-worlds/reference/index/interfaces/hexpathoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`HexPathResult`](/declarative-hex-worlds/reference/index/interfaces/hexpathresult/)

# findPlacementEntity

> **findPlacementEntity**(`world`, `placement`): `Entity` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:631](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L631)

Find a placement entity by entity reference or placement id. O(1) via per-world index maintained by spawn / remove helpers.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### placement

[Section titled “placement”](#placement)

`string` | `Entity`

## Returns

[Section titled “Returns”](#returns)

`Entity` | `undefined`

# findTileEntity

> **findTileEntity**(`world`, `coordinates`): `Entity` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:619](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L619)

Find a tile entity by axial coordinates or tile key. O(1) via per-world index maintained by spawnGameboardPlan / clearGameboardWorld.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

## Returns

[Section titled “Returns”](#returns)

`Entity` | `undefined`

# frameBoard

> **frameBoard**(`tiles`, `state?`): [`CameraFraming`](/declarative-hex-worlds/reference/index/interfaces/cameraframing/)

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:184](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L184)

One-shot framing straight from a board’s tiles + a view state — the common path for a binding’s `useCamera`. Equivalent to `computeCameraFraming(computeBoardBounds(tiles), state)`.

## Parameters

[Section titled “Parameters”](#parameters)

### tiles

[Section titled “tiles”](#tiles)

readonly [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)\[]

### state?

[Section titled “state?”](#state)

[`CameraState`](/declarative-hex-worlds/reference/index/interfaces/camerastate/) = `DEFAULT_CAMERA_STATE`

## Returns

[Section titled “Returns”](#returns)

[`CameraFraming`](/declarative-hex-worlds/reference/index/interfaces/cameraframing/)

# gameboardActorBlocksMovement

> **gameboardActorBlocksMovement**(`actor`, `placement?`, `profile?`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:1380](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L1380)

Evaluate whether an actor/placement combination blocks movement under a collision profile.

## Parameters

[Section titled “Parameters”](#parameters)

### actor

[Section titled “actor”](#actor)

{ `actorId`: `string`; `blocksMovement`: `boolean`; `faction`: `string` | `undefined`; `hostile`: `boolean`; `interactive`: `boolean`; `kind`: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/); `metadata`: `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>; `tags`: `string`\[]; `team`: `string` | `undefined`; } | `undefined`

#### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `actorId`: `string`; `blocksMovement`: `boolean`; `faction`: `string` | `undefined`; `hostile`: `boolean`; `interactive`: `boolean`; `kind`: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/); `metadata`: `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>; `tags`: `string`\[]; `team`: `string` | `undefined`; }

##### actorId

[Section titled “actorId”](#actorid)

`string` = `''`

Stable gameplay actor id.

##### blocksMovement

[Section titled “blocksMovement”](#blocksmovement)

`boolean` = `false`

Whether this actor blocks movement.

##### faction

[Section titled “faction”](#faction)

`string` | `undefined` = `...`

Optional faction identifier.

##### hostile

[Section titled “hostile”](#hostile)

`boolean` = `false`

Whether this actor is generally hostile.

##### interactive

[Section titled “interactive”](#interactive)

`boolean` = `false`

Whether this actor should be treated as an interaction target.

##### kind

[Section titled “kind”](#kind)

[`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/) = `...`

Actor role used by collision, targeting, commands, and fixtures.

##### metadata

[Section titled “metadata”](#metadata)

`Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)> = `...`

Serializable actor metadata.

##### tags

[Section titled “tags”](#tags)

`string`\[] = `...`

Free-form actor tags.

##### team

[Section titled “team”](#team)

`string` | `undefined` = `...`

Optional team identifier.

***

`undefined`

### placement?

[Section titled “placement?”](#placement)

`Pick`<[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/), `"kind"` | `"layer"`>

### profile?

[Section titled “profile?”](#profile)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/) = `{}`

## Returns

[Section titled “Returns”](#returns)

`boolean`

# gameboardAssetUrl

> **gameboardAssetUrl**(`asset`): `string`

Defined in: [packages/declarative-hex-worlds/src/runtime/asset-root.ts:96](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/asset-root.ts#L96)

Convenience wrapper: returns the URL of `asset` under the resolved bootstrap asset root. Equivalent to `joinUrl(resolveGameboardAssetRoot(), rewriteToBootstrapPath(asset))`.

## Parameters

[Section titled “Parameters”](#parameters)

### asset

[Section titled “asset”](#asset)

[`MedievalHexagonAsset`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonasset/)

## Returns

[Section titled “Returns”](#returns)

`string`

# gameboardPlanIndex

> **gameboardPlanIndex**(`plan`): [`GameboardPlanIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanindex/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:246](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L246)

Return memoized indexes for a [GameboardPlan](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/), building them lazily the first time and caching per-plan thereafter (PRD B4).

Hot-path callers should prefer this over inlining `new Map(plan.tiles.map(...))` — that rebuild cost shows up under profiling on every render of large boards.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlanIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanindex/)

# getGameboardAssetRootOverride

> **getGameboardAssetRootOverride**(): `string` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/runtime/asset-root.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/asset-root.ts#L65)

Returns the currently configured process-wide asset root override, if any.

## Returns

[Section titled “Returns”](#returns)

`string` | `undefined`

# getPlacementAsset

> **getPlacementAsset**(`placement`, `manifest`): [`MedievalHexagonAsset`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonasset/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/gameboard/assets.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/assets.ts#L45)

Resolve a placement’s asset from a manifest.

## Parameters

[Section titled “Parameters”](#parameters)

### placement

[Section titled “placement”](#placement)

`Pick`<[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/), `"assetId"`>

### manifest

[Section titled “manifest”](#manifest)

[`MedievalHexagonManifest`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifest/)

## Returns

[Section titled “Returns”](#returns)

[`MedievalHexagonAsset`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonasset/) | `undefined`

# guessGameplayCategory

> **guessGameplayCategory**(`path`): `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:170](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L170)

Guess a model/sprite asset’s SUGGESTED gameplay category from its filename, or `undefined` when no keyword matches (an uncategorized model). A default the dev accepts or overrides — never authoritative.

Substring (not token) match is deliberate: asset packs favour compound names where the keyword is fused into a word — `watchtower` (→ structure via `tower`), `treehouse`, `crossbowman`. Requiring a whole-token match would miss those. List order breaks ties when a name carries two keywords (`skeleton_warrior` → enemy, checked before pc). The result is only ever a SUGGESTION the developer confirms or overrides, so an occasional loose hit costs nothing — it’s one click to correct in the wizard/web flow.

## Parameters

[Section titled “Parameters”](#parameters)

### path

[Section titled “path”](#path)

`string`

## Returns

[Section titled “Returns”](#returns)

`"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"` | `undefined`

# guessTileBiome

> **guessTileBiome**(`path`): `string`

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:115](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L115)

Guess a tile’s biome from its filename (e.g. `hex_grass_A` → `grass`). Falls back to `'unknown'` when no keyword matches — the CLI surfaces these for the author to fix.

## Parameters

[Section titled “Parameters”](#parameters)

### path

[Section titled “path”](#path)

`string`

## Returns

[Section titled “Returns”](#returns)

`string`

# hexDistance

> **hexDistance**(`left`, `right`): `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:168](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L168)

Computes axial hex distance between two coordinates.

## Parameters

[Section titled “Parameters”](#parameters)

### left

[Section titled “left”](#left)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### right

[Section titled “right”](#right)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

## Returns

[Section titled “Returns”](#returns)

`number`

# hexKey

> **hexKey**(`coordinates`): `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:71](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L71)

Converts axial coordinates into a stable string key.

## Parameters

[Section titled “Parameters”](#parameters)

### coordinates

[Section titled “coordinates”](#coordinates)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

## Returns

[Section titled “Returns”](#returns)

`string`

# hexLine

> **hexLine**(`start`, `end`): [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:176](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L176)

Returns a rounded axial line between two coordinates, inclusive.

## Parameters

[Section titled “Parameters”](#parameters)

### start

[Section titled “start”](#start)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### end

[Section titled “end”](#end)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

## Returns

[Section titled “Returns”](#returns)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

# hexRange

> **hexRange**(`center`, `radius`): [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:208](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L208)

Returns all coordinates within a radius of a center.

## Parameters

[Section titled “Parameters”](#parameters)

### center

[Section titled “center”](#center)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### radius

[Section titled “radius”](#radius)

`number`

## Returns

[Section titled “Returns”](#returns)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

# hexRing

> **hexRing**(`center`, `radius`): [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:187](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L187)

Returns coordinates exactly one radius away from a center.

## Parameters

[Section titled “Parameters”](#parameters)

### center

[Section titled “center”](#center)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### radius

[Section titled “radius”](#radius)

`number`

## Returns

[Section titled “Returns”](#returns)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

# indexGameboardInteropSnapshot

> **indexGameboardInteropSnapshot**(`snapshot`): `ReadonlyMap`<`string`, [`GameboardInteropEntity`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropentity/)>

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:831](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L831)

Return only the entity index for an interop snapshot.

## Parameters

[Section titled “Parameters”](#parameters)

### snapshot

[Section titled “snapshot”](#snapshot)

[`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

## Returns

[Section titled “Returns”](#returns)

`ReadonlyMap`<`string`, [`GameboardInteropEntity`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropentity/)>

# indexTextureBindings

> **indexTextureBindings**(`bindings`): [`TextureBindingIndex`](/declarative-hex-worlds/reference/index/type-aliases/texturebindingindex/)

Defined in: [packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts#L33)

Build a lookup index from a flat list of texture bindings (grouped by assetId).

## Parameters

[Section titled “Parameters”](#parameters)

### bindings

[Section titled “bindings”](#bindings)

readonly [`TextureBinding`](/declarative-hex-worlds/reference/index/interfaces/texturebinding/)\[]

## Returns

[Section titled “Returns”](#returns)

[`TextureBindingIndex`](/declarative-hex-worlds/reference/index/type-aliases/texturebindingindex/)

# inferTilesetGrid

> **inferTilesetGrid**(`dimensions`, `cols`, `rows`): `object`

Defined in: [packages/declarative-hex-worlds/src/asset-source/png-dimensions.ts:61](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/png-dimensions.ts#L61)

Infer a tileset grid from the atlas dimensions + a known column/row count. The common case: the author knows the sheet is `cols × rows` cells (the CLI takes `--cols`/`--rows`), and the cell size is the exact integer division of the atlas. Throws if the dimensions don’t divide evenly — a mismatch means the cols/rows are wrong and the emitted grid would mis-slice every cell.

## Parameters

[Section titled “Parameters”](#parameters)

### dimensions

[Section titled “dimensions”](#dimensions)

[`PngDimensions`](/declarative-hex-worlds/reference/index/interfaces/pngdimensions/)

### cols

[Section titled “cols”](#cols)

`number`

### rows

[Section titled “rows”](#rows)

`number`

## Returns

[Section titled “Returns”](#returns)

`object`

### cellHeight

[Section titled “cellHeight”](#cellheight)

> **cellHeight**: `number`

### cellWidth

[Section titled “cellWidth”](#cellwidth)

> **cellWidth**: `number`

### cols

[Section titled “cols”](#cols-1)

> **cols**: `number`

### rows

[Section titled “rows”](#rows-1)

> **rows**: `number`

# inspectGameboardActorCollision

> **inspectGameboardActorCollision**(`world`, `actor`, `target`, `profile?`): [`GameboardActorCollisionReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionreport/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:1057](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L1057)

Inspect whether an actor can enter a target tile under a collision profile.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### actor

[Section titled “actor”](#actor)

`string` | `Entity` | `undefined`

### target

[Section titled “target”](#target)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### profile?

[Section titled “profile?”](#profile)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardActorCollisionReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionreport/)

# inspectGameboardActorTargets

> **inspectGameboardActorTargets**(`world`, `options`): [`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:961](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L961)

Select candidate target actors for a source actor and evaluate reachability using actor-aware navigation.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### options

[Section titled “options”](#options)

[`GameboardActorTargetingOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/)

# inspectGameboardInteractionTarget

> **inspectGameboardInteractionTarget**(`world`, `target`, `options?`): [`GameboardInteractionTargetReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetreport/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:1150](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L1150)

Resolve a target input into an interaction target report.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### target

[Section titled “target”](#target)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

### options?

[Section titled “options?”](#options)

[`GameboardInteractionTargetOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardInteractionTargetReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetreport/)

# inspectGameboardNeighborhood

> **inspectGameboardNeighborhood**(`world`, `center`, `options?`): [`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:1230](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L1230)

Inspect a radius of tiles around a center and aggregate actor/tile summaries.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### center

[Section titled “center”](#center)

[`GameboardNeighborhoodCenter`](/declarative-hex-worlds/reference/index/type-aliases/gameboardneighborhoodcenter/)

### options?

[Section titled “options?”](#options)

[`GameboardNeighborhoodInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspectionoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

# inspectGameboardPiecePlacement

> **inspectGameboardPiecePlacement**(`plan`, `piece`, `options?`): [`GameboardPiecePlacementInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementinspection/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:679](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L679)

Inspect candidate sites and generated placements for one piece.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### piece

[Section titled “piece”](#piece)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

### options?

[Section titled “options?”](#options)

[`GameboardPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPiecePlacementInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementinspection/)

# inspectGameboardPlacementOccupancy

> **inspectGameboardPlacementOccupancy**(`world`, `options`): [`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:727](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L727)

Inspect a proposed placement footprint without mutating the world.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### options

[Section titled “options”](#options)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/)

# inspectGameboardScenario

> **inspectGameboardScenario**(`scenario`, `config?`): [`GameboardScenarioValidationResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariovalidationresult/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:361](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L361)

Compiles and validates a scenario, returning errors instead of throwing.

## Parameters

[Section titled “Parameters”](#parameters)

### scenario

[Section titled “scenario”](#scenario)

[`GameboardScenario`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenario/)

### config?

[Section titled “config?”](#config)

[`GameboardScenarioValidationConfig`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariovalidationconfig/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardScenarioValidationResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariovalidationresult/)

# inspectGameboardScenarioSimulationScript

> **inspectGameboardScenarioSimulationScript**(`script`, `config?`): [`GameboardScenarioSimulationScriptValidationResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationscriptvalidationresult/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-validators.ts:52](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-validators.ts#L52)

Validates a simulation script against optional scenario or compiled plan context without executing it.

## Parameters

[Section titled “Parameters”](#parameters)

### script

[Section titled “script”](#script)

[`GameboardScenarioSimulationScript`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationscript/)

### config?

[Section titled “config?”](#config)

[`GameboardScenarioSimulationScriptValidationConfig`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationscriptvalidationconfig/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardScenarioSimulationScriptValidationResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationscriptvalidationresult/)

# inspectGameboardTile

> **inspectGameboardTile**(`world`, `coordinates`, `options?`): [`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:1186](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L1186)

Inspect one tile from an actor/gameplay perspective.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### options?

[Section titled “options?”](#options)

[`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

# inspectSeededGameboardPieceFills

> **inspectSeededGameboardPieceFills**(`plan`, `registry`, `fills`, `options?`): [`SeededGameboardPieceFillInspection`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefillinspection/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:503](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L503)

Dry-runs seeded piece fill selection, scoring, and placement for a plan.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### registry

[Section titled “registry”](#registry)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

### fills

[Section titled “fills”](#fills)

readonly [`SeededGameboardPieceFillOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefilloptions/)\[]

### options?

[Section titled “options?”](#options)

[`InspectSeededGameboardPieceFillsOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectseededgameboardpiecefillsoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`SeededGameboardPieceFillInspection`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefillinspection/)

# inspectSeededGameboardPieceFillSelections

> **inspectSeededGameboardPieceFillSelections**(`registry`, `fills`): [`SeededGameboardPieceFillSelectionInspection`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefillselectioninspection/)\[]

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:528](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L528)

Inspects which registered pieces each seeded piece-fill option selects.

## Parameters

[Section titled “Parameters”](#parameters)

### registry

[Section titled “registry”](#registry)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

### fills

[Section titled “fills”](#fills)

readonly [`SeededGameboardPieceFillOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefilloptions/)\[]

## Returns

[Section titled “Returns”](#returns)

[`SeededGameboardPieceFillSelectionInspection`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefillselectioninspection/)\[]

# isCoverableCoastMask

> **isCoverableCoastMask**(`edges`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:260](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L260)

True if `mask` is coverable by a coast tile — i.e. it is 0 (no coast) or a rotation of some COAST\_VARIANT canonical mask (a CONTIGUOUS run of 1-5 water edges). Non-contiguous masks (e.g. `0b010101` from edges \[0,2,4]) have no coast tile: a single hex tile can only depict one unbroken coastline arc.

## Parameters

[Section titled “Parameters”](#parameters)

### edges

[Section titled “edges”](#edges)

[`HexEdgeInput`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeinput/)

## Returns

[Section titled “Returns”](#returns)

`boolean`

# isGameboardInteractionHandlerPreset

> **isGameboardInteractionHandlerPreset**(`value`): value is “remove-target-actor” | “remove-target-placement” | “mark-target-interacted” | “default-rpg”

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:639](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L639)

Runtime guard for handler preset ids.

## Parameters

[Section titled “Parameters”](#parameters)

### value

[Section titled “value”](#value)

`unknown`

## Returns

[Section titled “Returns”](#returns)

value is “remove-target-actor” | “remove-target-placement” | “mark-target-interacted” | “default-rpg”

# isTransitionFamily

> **isTransitionFamily**(`value`): value is “coast” | “road” | “river”

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:133](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L133)

True if `value` names a known transition family. Uses `Object.hasOwn` (not `in`) so inherited `Object.prototype` keys (`constructor`, `toString`, …) don’t spuriously match — a `selectTransitionVariant`/`resolveEdge` miss must fall through, and matching an inherited key would index the table with a non-array.

## Parameters

[Section titled “Parameters”](#parameters)

### value

[Section titled “value”](#value)

`string`

## Returns

[Section titled “Returns”](#returns)

value is “coast” | “road” | “river”

# linkAdjacentTiles

> **linkAdjacentTiles**(`tiles`): `void`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:586](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L586)

Add directional `AdjacentTo` relations for every neighboring tile pair in an already constructed tile index.

## Parameters

[Section titled “Parameters”](#parameters)

### tiles

[Section titled “tiles”](#tiles)

`ReadonlyMap`<`string`, `Entity`>

## Returns

[Section titled “Returns”](#returns)

`void`

# listClassifiersInWorld

> **listClassifiersInWorld**(`world`): readonly [`ClassifierTag`](/declarative-hex-worlds/reference/index/type-aliases/classifiertag/)\[]

Defined in: [packages/declarative-hex-worlds/src/classifiers/classifiers-runtime.ts:34](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/classifiers/classifiers-runtime.ts#L34)

Distinct classifier tags present across all placements in `world`.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

## Returns

[Section titled “Returns”](#returns)

readonly [`ClassifierTag`](/declarative-hex-worlds/reference/index/type-aliases/classifiertag/)\[]

# listCoastGuidePermutations

> **listCoastGuidePermutations**(`options?`): [`GuideTilePermutation`](/declarative-hex-worlds/reference/index/interfaces/guidetilepermutation/)\[]

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:388](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L388)

Lists every requested coast guide variant/rotation/waterless permutation.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`GuidePermutationOptions`](/declarative-hex-worlds/reference/index/interfaces/guidepermutationoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GuideTilePermutation`](/declarative-hex-worlds/reference/index/interfaces/guidetilepermutation/)\[]

# listGuideTilePermutations

> **listGuideTilePermutations**(): [`GuideTilePermutation`](/declarative-hex-worlds/reference/index/interfaces/guidetilepermutation/)\[]

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:407](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L407)

Lists the full guide permutation matrix used by visual coverage tests.

## Returns

[Section titled “Returns”](#returns)

[`GuideTilePermutation`](/declarative-hex-worlds/reference/index/interfaces/guidetilepermutation/)\[]

# listPropClusterAssets

> **listPropClusterAssets**(`kind`, `options?`): readonly (`"tent"` | `"anchor"` | `"barrel"` | `"boat"` | `"boatrack"` | `"bucket_arrows"` | `"bucket_empty"` | `"bucket_water"` | `"cannonball_pallet"` | `"crate_A_big"` | `"crate_A_small"` | `"crate_B_big"` | `"crate_B_small"` | `"crate_long_A"` | `"crate_long_B"` | `"crate_long_C"` | `"crate_long_empty"` | `"crate_open"` | `"flag_blue"` | `"flag_green"` | `"flag_red"` | `"flag_yellow"` | `"haybale"` | `"icon_combat"` | `"icon_range"` | `"ladder"` | `"pallet"` | `"resource_lumber"` | `"resource_stone"` | `"sack"` | `"target"` | `"trough"` | `"trough_long"` | `"weaponrack"` | `"wheelbarrow"`)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/assets.ts:73](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/assets.ts#L73)

List the default prop assets used by a semantic cluster kind.

## Parameters

[Section titled “Parameters”](#parameters)

### kind

[Section titled “kind”](#kind)

[`PropClusterKind`](/declarative-hex-worlds/reference/index/type-aliases/propclusterkind/)

### options?

[Section titled “options?”](#options)

#### includeExtra?

[Section titled “includeExtra?”](#includeextra)

`boolean`

## Returns

[Section titled “Returns”](#returns)

readonly (`"tent"` | `"anchor"` | `"barrel"` | `"boat"` | `"boatrack"` | `"bucket_arrows"` | `"bucket_empty"` | `"bucket_water"` | `"cannonball_pallet"` | `"crate_A_big"` | `"crate_A_small"` | `"crate_B_big"` | `"crate_B_small"` | `"crate_long_A"` | `"crate_long_B"` | `"crate_long_C"` | `"crate_long_empty"` | `"crate_open"` | `"flag_blue"` | `"flag_green"` | `"flag_red"` | `"flag_yellow"` | `"haybale"` | `"icon_combat"` | `"icon_range"` | `"ladder"` | `"pallet"` | `"resource_lumber"` | `"resource_stone"` | `"sack"` | `"target"` | `"trough"` | `"trough_long"` | `"weaponrack"` | `"wheelbarrow"`)\[]

# listRiverCrossingGuidePermutations

> **listRiverCrossingGuidePermutations**(`options?`): [`GuideTilePermutation`](/declarative-hex-worlds/reference/index/interfaces/guidetilepermutation/)\[]

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:364](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L364)

Lists every requested river crossing guide waterless permutation.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

`Pick`<[`GuidePermutationOptions`](/declarative-hex-worlds/reference/index/interfaces/guidepermutationoptions/), `"waterless"`> = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GuideTilePermutation`](/declarative-hex-worlds/reference/index/interfaces/guidetilepermutation/)\[]

# listRiverCurvyGuidePermutations

> **listRiverCurvyGuidePermutations**(`options?`): [`GuideTilePermutation`](/declarative-hex-worlds/reference/index/interfaces/guidetilepermutation/)\[]

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:344](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L344)

Lists every requested curvy river guide rotation/waterless permutation.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`GuidePermutationOptions`](/declarative-hex-worlds/reference/index/interfaces/guidepermutationoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GuideTilePermutation`](/declarative-hex-worlds/reference/index/interfaces/guidetilepermutation/)\[]

# listRiverGuidePermutations

> **listRiverGuidePermutations**(`options?`): [`GuideTilePermutation`](/declarative-hex-worlds/reference/index/interfaces/guidetilepermutation/)\[]

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:325](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L325)

Lists every requested river guide variant/rotation/waterless permutation.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`GuidePermutationOptions`](/declarative-hex-worlds/reference/index/interfaces/guidepermutationoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GuideTilePermutation`](/declarative-hex-worlds/reference/index/interfaces/guidetilepermutation/)\[]

# listRoadGuidePermutations

> **listRoadGuidePermutations**(`options?`): [`GuideTilePermutation`](/declarative-hex-worlds/reference/index/interfaces/guidetilepermutation/)\[]

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:309](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L309)

Lists every requested road guide variant/rotation permutation.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

`Pick`<[`GuidePermutationOptions`](/declarative-hex-worlds/reference/index/interfaces/guidepermutationoptions/), `"rotationSteps"`> = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GuideTilePermutation`](/declarative-hex-worlds/reference/index/interfaces/guidetilepermutation/)\[]

# loadPlacementAsset

> **loadPlacementAsset**(`placement`): `Promise`<[`MedievalHexagonAsset`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonasset/) | `undefined`>

Defined in: [packages/declarative-hex-worlds/src/gameboard/assets.ts:55](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/assets.ts#L55)

Resolve a placement’s asset from the packaged FREE manifest.

## Parameters

[Section titled “Parameters”](#parameters)

### placement

[Section titled “placement”](#placement)

`Pick`<[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/), `"assetId"`>

## Returns

[Section titled “Returns”](#returns)

`Promise`<[`MedievalHexagonAsset`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonasset/) | `undefined`>

# minHeapCreate

> **minHeapCreate**<`T`>(`compare`): `T`\[] & `object`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:329](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L329)

Binary min-heap — O(log N) push/pop.

## Type Parameters

[Section titled “Type Parameters”](#type-parameters)

### T

[Section titled “T”](#t)

`T`

## Parameters

[Section titled “Parameters”](#parameters)

### compare

[Section titled “compare”](#compare)

(`a`, `b`) => `number`

## Returns

[Section titled “Returns”](#returns)

`T`\[] & `object`

# minHeapPop

> **minHeapPop**<`T`>(`heap`): `T` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:354](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L354)

## Type Parameters

[Section titled “Type Parameters”](#type-parameters)

### T

[Section titled “T”](#t)

`T`

## Parameters

[Section titled “Parameters”](#parameters)

### heap

[Section titled “heap”](#heap)

`T`\[] & `object`

## Returns

[Section titled “Returns”](#returns)

`T` | `undefined`

# minHeapPush

> **minHeapPush**<`T`>(`heap`, `value`): `void`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:337](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L337)

## Type Parameters

[Section titled “Type Parameters”](#type-parameters)

### T

[Section titled “T”](#t)

`T`

## Parameters

[Section titled “Parameters”](#parameters)

### heap

[Section titled “heap”](#heap)

`T`\[] & `object`

### value

[Section titled “value”](#value)

`T`

## Returns

[Section titled “Returns”](#returns)

`void`

# mountGameboardInteropSnapshot

> **mountGameboardInteropSnapshot**<`TEntity`>(`snapshot`, `adapter`): [`GameboardEcsMountResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsmountresult/)<`TEntity`>

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:890](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L890)

Mount an interop snapshot into a host ECS adapter.

## Type Parameters

[Section titled “Type Parameters”](#type-parameters)

### TEntity

[Section titled “TEntity”](#tentity)

`TEntity`

## Parameters

[Section titled “Parameters”](#parameters)

### snapshot

[Section titled “snapshot”](#snapshot)

[`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

### adapter

[Section titled “adapter”](#adapter)

[`GameboardEcsAdapter`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsadapter/)<`TEntity`>

## Returns

[Section titled “Returns”](#returns)

[`GameboardEcsMountResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsmountresult/)<`TEntity`>

# moveGameboardActor

> **moveGameboardActor**(`world`, `actor`, `to`, `options?`): `Entity`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:841](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L841)

Move an actor to a new tile by delegating to placement movement.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### actor

[Section titled “actor”](#actor)

`string` | `Entity`

### to

[Section titled “to”](#to)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### options?

[Section titled “options?”](#options)

[`MoveGameboardActorOptions`](/declarative-hex-worlds/reference/index/type-aliases/movegameboardactoroptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

`Entity`

# moveGameboardPlacement

> **moveGameboardPlacement**(`world`, `placement`, `to`, `options?`): `Entity`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:556](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L556)

Move an existing placement to a new tile while allowing selected placement fields to be updated in the same operation.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### placement

[Section titled “placement”](#placement)

`string` | `Entity`

### to

[Section titled “to”](#to)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### options?

[Section titled “options?”](#options)

`Omit`<[`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/), `"at"`> = `{}`

## Returns

[Section titled “Returns”](#returns)

`Entity`

# neighbor

> **neighbor**(`coordinates`, `edge`): [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:110](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L110)

Returns the neighbor coordinate at a clockwise edge index.

## Parameters

[Section titled “Parameters”](#parameters)

### coordinates

[Section titled “coordinates”](#coordinates)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### edge

[Section titled “edge”](#edge)

`number`

## Returns

[Section titled “Returns”](#returns)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

# neighbors

> **neighbors**(`coordinates`): [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:116](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L116)

Returns all six neighboring axial coordinates.

## Parameters

[Section titled “Parameters”](#parameters)

### coordinates

[Section titled “coordinates”](#coordinates)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

## Returns

[Section titled “Returns”](#returns)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

# normalizeAssetToCell

> **normalizeAssetToCell**(`bounds`, `options?`): [`Normalization`](/declarative-hex-worlds/reference/index/interfaces/normalization/)

Defined in: [packages/declarative-hex-worlds/src/normalize/normalize.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/normalize/normalize.ts#L65)

Compute the uniform scale + recenter offset that normalizes an asset’s native bounds onto a board cell. The scale fits the footprint per `fit`; the offset re-centers the scaled asset on the cell (x/z) and rests it on the surface (or centers it in y).

## Parameters

[Section titled “Parameters”](#parameters)

### bounds

[Section titled “bounds”](#bounds)

[`AssetBounds`](/declarative-hex-worlds/reference/types/interfaces/assetbounds/)

### options?

[Section titled “options?”](#options)

[`NormalizeOptions`](/declarative-hex-worlds/reference/index/interfaces/normalizeoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`Normalization`](/declarative-hex-worlds/reference/index/interfaces/normalization/)

# normalizedFootprint

> **normalizedFootprint**(`bounds`, `normalization`): `object`

Defined in: [packages/declarative-hex-worlds/src/normalize/normalize.ts:110](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/normalize/normalize.ts#L110)

The world footprint (width × depth) an asset occupies after a normalization.

## Parameters

[Section titled “Parameters”](#parameters)

### bounds

[Section titled “bounds”](#bounds)

[`AssetBounds`](/declarative-hex-worlds/reference/types/interfaces/assetbounds/)

### normalization

[Section titled “normalization”](#normalization)

[`Normalization`](/declarative-hex-worlds/reference/index/interfaces/normalization/)

## Returns

[Section titled “Returns”](#returns)

`object`

### depth

[Section titled “depth”](#depth)

> **depth**: `number`

### height

[Section titled “height”](#height)

> **height**: `number`

### width

[Section titled “width”](#width)

> **width**: `number`

# normalizeHexRotationSteps

> **normalizeHexRotationSteps**(`steps`): [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:324](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L324)

Normalizes any integer-ish rotation step value into the range 0 through 5.

## Parameters

[Section titled “Parameters”](#parameters)

### steps

[Section titled “steps”](#steps)

`number`

## Returns

[Section titled “Returns”](#returns)

[`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

# oppositeEdge

> **oppositeEdge**(`edge`): [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:121](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L121)

Returns the opposite edge index for a given edge.

## Parameters

[Section titled “Parameters”](#parameters)

### edge

[Section titled “edge”](#edge)

`number`

## Returns

[Section titled “Returns”](#returns)

[`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

# overlayTransform

> **overlayTransform**(`tilePosition`, `normalization`, `controls?`, `base?`): [`AssetTransform`](/declarative-hex-worlds/reference/index/interfaces/assettransform/)

Defined in: [packages/declarative-hex-worlds/src/overlay/overlay.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/overlay/overlay.ts#L45)

Compose a normalized asset onto a tile at `tilePosition` with overlay controls, yielding the final `AssetTransform`. Order: normalized recenter → anchor within the cell → tile position → dev offset; scale = normalized × control multiplier; rotation = base + control.

## Parameters

[Section titled “Parameters”](#parameters)

### tilePosition

[Section titled “tilePosition”](#tileposition)

[`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

### normalization

[Section titled “normalization”](#normalization)

[`Normalization`](/declarative-hex-worlds/reference/index/interfaces/normalization/)

### controls?

[Section titled “controls?”](#controls)

[`OverlayControls`](/declarative-hex-worlds/reference/index/interfaces/overlaycontrols/) = `{}`

### base?

[Section titled “base?”](#base)

#### rotationY?

[Section titled “rotationY?”](#rotationy)

`number`

## Returns

[Section titled “Returns”](#returns)

[`AssetTransform`](/declarative-hex-worlds/reference/index/interfaces/assettransform/)

# packClassifier

> **packClassifier**(`packId`, `category`, `assetIdPrefix?`): [`PlacementClassifier`](/declarative-hex-worlds/reference/index/type-aliases/placementclassifier/)

Defined in: [packages/declarative-hex-worlds/src/classifiers/classifiers.ts:113](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/classifiers/classifiers.ts#L113)

Build a [PlacementClassifier](/declarative-hex-worlds/reference/index/type-aliases/placementclassifier/) for a recognized pack (RFC0-TAGb). A placement belongs to the pack when EITHER its `sourcePack` metadata equals `packId` OR its `assetId` is namespaced under `<packId>:` (the `adventurer:knight` convention). Matching placements receive the pack category’s default classifiers ([packDefaultClassifiers](/declarative-hex-worlds/reference/index/functions/packdefaultclassifiers/)); everything else gets none, so pack classifiers compose cleanly on top of the kind-based [DEFAULT\_PLACEMENT\_CLASSIFIERS](/declarative-hex-worlds/reference/index/variables/default_placement_classifiers/).

## Parameters

[Section titled “Parameters”](#parameters)

### packId

[Section titled “packId”](#packid)

`string`

The registered pack id (e.g. `adventurers`, `skeletons`).

### category

[Section titled “category”](#category)

[`PackClassifierCategory`](/declarative-hex-worlds/reference/index/type-aliases/packclassifiercategory/)

The pack’s registry category (thread `packDescriptor(id).category`).

### assetIdPrefix?

[Section titled “assetIdPrefix?”](#assetidprefix)

`string` = `packId`

Optional `assetId` namespace to also match (defaults to `packId`).

## Returns

[Section titled “Returns”](#returns)

[`PlacementClassifier`](/declarative-hex-worlds/reference/index/type-aliases/placementclassifier/)

# packDefaultClassifiers

> **packDefaultClassifiers**(`category`): readonly (`"unit"` | `"prop"` | `"building"` | `"enemy"` | `"playable"` | `"non-playable"` | `"random-encounter"`)\[]

Defined in: [packages/declarative-hex-worlds/src/classifiers/classifiers.ts:81](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/classifiers/classifiers.ts#L81)

The default classifier tags a recognized pack’s CATEGORY contributes (RFC0-TAGb). `playable` characters are playable units; `enemy` characters are both enemies and eligible random encounters; `terrain` packs contribute no gameplay classifier (their pieces are classified by structural kind alone). This is the pack→classifier mapping the RFC0-TAG doc reserved (“Adventures → playable, Skeletons → enemy”).

## Parameters

[Section titled “Parameters”](#parameters)

### category

[Section titled “category”](#category)

[`PackClassifierCategory`](/declarative-hex-worlds/reference/index/type-aliases/packclassifiercategory/)

## Returns

[Section titled “Returns”](#returns)

readonly (`"unit"` | `"prop"` | `"building"` | `"enemy"` | `"playable"` | `"non-playable"` | `"random-encounter"`)\[]

# parseAssetSourceSpec

> **parseAssetSourceSpec**(`input`): `object`

Defined in: [packages/declarative-hex-worlds/src/asset-source/spec.ts:158](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/spec.ts#L158)

Parse + validate a spec, throwing a precise ZodError on invalid input.

## Parameters

[Section titled “Parameters”](#parameters)

### input

[Section titled “input”](#input)

`unknown`

## Returns

[Section titled “Returns”](#returns)

### assetRoot

[Section titled “assetRoot”](#assetroot)

> **assetRoot**: `string`

Root directory the asset paths are relative to (e.g. “public/assets”).

### assets

[Section titled “assets”](#assets)

> **assets**: ({ `biome`: `string`; `edgeMask?`: `number`; `format`: `"png"` | `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"tile"`; } | { `biome?`: `string`; `format`: `"png"`; `grid`: { `cellHeight`: `number`; `cellWidth`: `number`; `cols`: `number`; `rows`: `number`; }; `id`: `string`; `path`: `string`; `role`: `"tileset"`; `transition?`: { `edgeCells`: `Record`<`string`, `number`>; }; } | { `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"png"`; `id`: `string`; `path`: `string`; `role`: `"sprite"`; } | { `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"model"`; })\[]

Ordered asset records.

### name

[Section titled “name”](#name)

> **name**: `string`

Human-readable source name (e.g. “kaykit-free”, “my-tileset-pack”).

### specVersion

[Section titled “specVersion”](#specversion)

> **specVersion**: `1`

Spec format version (this schema is v1).

# parseHexKey

> **parseHexKey**(`key`): [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:82](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L82)

Parses a string key produced by [hexKey](/declarative-hex-worlds/reference/index/functions/hexkey/).

Throws on invalid input. Prefer [tryParseHexKey](/declarative-hex-worlds/reference/index/functions/tryparsehexkey/) on lookup paths where a miss is an expected outcome (returning `undefined` is \~100× faster than throwing + catching in V8).

## Parameters

[Section titled “Parameters”](#parameters)

### key

[Section titled “key”](#key)

`string`

## Returns

[Section titled “Returns”](#returns)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

# parseTilesetManifest

> **parseTilesetManifest**(`input`): `object`

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts:131](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts#L131)

Parse + validate a tileset manifest, throwing a ZodError on invalid data.

## Parameters

[Section titled “Parameters”](#parameters)

### input

[Section titled “input”](#input)

`unknown`

## Returns

[Section titled “Returns”](#returns)

`object`

### biomes

[Section titled “biomes”](#biomes)

> **biomes**: `Record`<`string`, { `select`: `"first"` | `"hash"`; `sheet`: `string`; }>

### kind

[Section titled “kind”](#kind)

> **kind**: `"tileset"`

### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> **schemaVersion**: `string`

### sheets

[Section titled “sheets”](#sheets)

> **sheets**: `Record`<`string`, { `edgeCells?`: `Record`<`string`, `number`>; `grid`: { `cellHeight`: `number`; `cellWidth`: `number`; `cols`: `number`; `rows`: `number`; }; `role`: `"transition"` | `"fill"`; `url`: `string`; `variants?`: `number`\[]; }>

# placementHasClassifier

> **placementHasClassifier**(`metadata`, `tag`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/classifiers/classifiers.ts:189](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/classifiers/classifiers.ts#L189)

True if a placement’s metadata flags the given classifier.

## Parameters

[Section titled “Parameters”](#parameters)

### metadata

[Section titled “metadata”](#metadata)

`Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

### tag

[Section titled “tag”](#tag)

[`ClassifierTag`](/declarative-hex-worlds/reference/index/type-aliases/classifiertag/)

## Returns

[Section titled “Returns”](#returns)

`boolean`

# planGameboardActorTargetCommand

> **planGameboardActorTargetCommand**(`world`, `options`): [`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:334](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L334)

Selects an actor target through actor-aware targeting rules and returns the command that would interact with or attack it.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### options

[Section titled “options”](#options)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

# planGameboardInteractionCommand

> **planGameboardInteractionCommand**(`world`, `target`, `options?`): [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:1300](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L1300)

Plan a high-level interaction command from a click/target input.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### target

[Section titled “target”](#target)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

### options?

[Section titled “options?”](#options)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

# previewGameboardInteractionCommand

> **previewGameboardInteractionCommand**(`world`, `commandOrTarget`, `options?`): [`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:367](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L367)

Previews an interaction command, including actor-aware movement path checks for move commands, without mutating the world.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

### options?

[Section titled “options?”](#options)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

# reachableGameboardMovementTiles

> **reachableGameboardMovementTiles**(`world`, `placement`, `options?`): [`GameboardReachableTile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardreachabletile/)\[]

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:337](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L337)

Return tiles reachable by a placement under its movement profile and budget.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### placement

[Section titled “placement”](#placement)

`string` | `Entity`

### options?

[Section titled “options?”](#options)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardReachableTile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardreachabletile/)\[]

# readGameboardActors

> **readGameboardActors**(`world`): [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:883](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L883)

Read all registered actor snapshots sorted by actor id.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

## Returns

[Section titled “Returns”](#returns)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

# readGameboardActorsForTile

> **readGameboardActorsForTile**(`world`, `coordinates`): [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:1018](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L1018)

Read actor snapshots whose origin tile matches the provided coordinates or key.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

# readGameboardPatrolAgents

> **readGameboardPatrolAgents**(`world`): [`GameboardPatrolSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:213](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L213)

Read all patrol agents sorted by route id and placement id.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPatrolSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/)\[]

# readGameboardPlacementOccupancy

> **readGameboardPlacementOccupancy**(`world`): [`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:687](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L687)

Read every placement-to-tile occupancy relation in the world.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

## Returns

[Section titled “Returns”](#returns)

[`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

# readGameboardPlacements

> **readGameboardPlacements**(`world`): `object`\[]

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:652](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L652)

Read placement state snapshots sorted by render order and placement id.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

## Returns

[Section titled “Returns”](#returns)

# readGameboardQuests

> **readGameboardQuests**(`world`): [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:234](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L234)

Read all quest snapshots sorted by quest id.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

## Returns

[Section titled “Returns”](#returns)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

# readGameboardSnapshot

> **readGameboardSnapshot**(`world`): [`GameboardSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:820](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L820)

Read a serializable snapshot of board metadata, tiles, and placements.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

## Returns

[Section titled “Returns”](#returns)

[`GameboardSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardsnapshot/)

# readGameboardTiles

> **readGameboardTiles**(`world`): `object`\[]

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:641](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L641)

Read tile state snapshots sorted by axial tile key.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

## Returns

[Section titled “Returns”](#returns)

# readPlacementOccupancyForTile

> **readPlacementOccupancyForTile**(`world`, `coordinates`): [`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:703](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L703)

Read all occupancy records for one tile.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

## Returns

[Section titled “Returns”](#returns)

[`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

# readPlacementsForTile

> **readPlacementsForTile**(`world`, `coordinates`): `object`\[]

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:665](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L665)

Read placements that occupy a tile, including multi-tile footprint occupants.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

## Returns

[Section titled “Returns”](#returns)

# readPngDimensions

> **readPngDimensions**(`bytes`): [`PngDimensions`](/declarative-hex-worlds/reference/index/interfaces/pngdimensions/)

Defined in: [packages/declarative-hex-worlds/src/asset-source/png-dimensions.ts:28](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/png-dimensions.ts#L28)

Read the pixel width + height from a PNG’s IHDR chunk. Accepts the raw file bytes (a `Uint8Array`/`Buffer`). Throws if the data isn’t a PNG or is too short to hold an IHDR — a caller feeding a non-PNG should fail loudly, not silently mis-size.

## Parameters

[Section titled “Parameters”](#parameters)

### bytes

[Section titled “bytes”](#bytes)

`Uint8Array`

## Returns

[Section titled “Returns”](#returns)

[`PngDimensions`](/declarative-hex-worlds/reference/index/interfaces/pngdimensions/)

# readTintOpacity

> **readTintOpacity**(`metadata`): `object`

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset.ts:144](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset.ts#L144)

The per-placement tint + opacity read off flat placement metadata, so a game can drive fog-of-war / season / team shading over a shared atlas from the sim. Metadata is flat (`Record<string, string|number|boolean|null>`), so the tint is carried as three sibling keys:

* `tintR` / `tintG` / `tintB` (channels `[0, 1]`) → `tint` — ONLY when ALL three are present AND finite numbers (a partial/typo’d tint is ignored, never a half-applied colour);
* `opacity` (a number) → `opacity` — ONLY when it’s a finite number in `[0, 1]`. Anything else is omitted, leaving the request on its default opaque/untinted path.

## Parameters

[Section titled “Parameters”](#parameters)

### metadata

[Section titled “metadata”](#metadata)

`Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

## Returns

[Section titled “Returns”](#returns)

`object`

### opacity?

[Section titled “opacity?”](#opacity)

> `optional` **opacity?**: `number`

### tint?

[Section titled “tint?”](#tint)

> `optional` **tint?**: [`AssetTint`](/declarative-hex-worlds/reference/index/interfaces/assettint/)

# registerGameboardActor

> **registerGameboardActor**(`world`, `placement`, `options`): `Entity`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:794](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L794)

Attach actor state to an existing placement entity or placement id.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### placement

[Section titled “placement”](#placement)

`string` | `Entity`

### options

[Section titled “options”](#options)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/)

## Returns

[Section titled “Returns”](#returns)

`Entity`

# removeGameboardPlacement

> **removeGameboardPlacement**(`world`, `placement`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:568](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L568)

Remove a placement entity by entity reference or placement id.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### placement

[Section titled “placement”](#placement)

`string` | `Entity`

## Returns

[Section titled “Returns”](#returns)

`boolean`

# requestGameboardMovement

> **requestGameboardMovement**(`world`, `placement`, `destination`, `options?`): [`GameboardMovementRequestResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementrequestresult/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:352](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L352)

Request movement for a placement and write path state back to its entity.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### placement

[Section titled “placement”](#placement)

`string` | `Entity`

### destination

[Section titled “destination”](#destination)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### options?

[Section titled “options?”](#options)

[`GameboardMovementPathRequestOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementpathrequestoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardMovementRequestResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementrequestresult/)

# requiresExtraAsset

> **requiresExtraAsset**(`assetId`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/assets.ts:66](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/assets.ts#L66)

Return whether an asset id requires a local EXTRA edition asset.

## Parameters

[Section titled “Parameters”](#parameters)

### assetId

[Section titled “assetId”](#assetid)

`string`

## Returns

[Section titled “Returns”](#returns)

`boolean`

# resetGameboardMovementBudget

> **resetGameboardMovementBudget**(`world`, `placement?`, `options?`): readonly `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:436](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L436)

Reset the movement budget for one placement or all movement agents.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### placement?

[Section titled “placement?”](#placement)

`string` | `Entity`

### options?

[Section titled “options?”](#options)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

readonly `Entity`\[]

# resolveAccessoryTransform

> **resolveAccessoryTransform**(`transform?`): [`ResolvedAccessoryTransform`](/declarative-hex-worlds/reference/index/interfaces/resolvedaccessorytransform/)

Defined in: [packages/declarative-hex-worlds/src/accessories/accessories.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/accessories/accessories.ts#L47)

Fill in the defaults of an accessory local transform.

## Parameters

[Section titled “Parameters”](#parameters)

### transform?

[Section titled “transform?”](#transform)

[`AccessoryLocalTransform`](/declarative-hex-worlds/reference/index/interfaces/accessorylocaltransform/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`ResolvedAccessoryTransform`](/declarative-hex-worlds/reference/index/interfaces/resolvedaccessorytransform/)

# resolveAssetUrl

> **resolveAssetUrl**(`asset`, `baseUrl?`): `string`

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:51](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L51)

Resolves a manifest asset’s model path with an optional base URL.

## Parameters

[Section titled “Parameters”](#parameters)

### asset

[Section titled “asset”](#asset)

[`MedievalHexagonAsset`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonasset/)

### baseUrl?

[Section titled “baseUrl?”](#baseurl)

`string` | `URL`

## Returns

[Section titled “Returns”](#returns)

`string`

# resolveAssetUrlById

> **resolveAssetUrlById**(`assetId`, `options?`): `string` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L88)

Resolve a model URL for a bare asset id (no placement) from the explicit `assetUrls` map or the manifest catalog. Used by transition-edge resolution (RFC0-9b), where the input is a variant asset id (e.g. `hex_coast_B`) rather than a placement — so the placement-only paths (metadata.sourceUrl, fallback) don’t apply. Returns `undefined` when neither the map nor the catalog resolves.

## Parameters

[Section titled “Parameters”](#parameters)

### assetId

[Section titled “assetId”](#assetid)

`string`

### options?

[Section titled “options?”](#options)

[`GameboardPlacementAssetUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

`string` | `undefined`

# resolveGameboardAssetRoot

> **resolveGameboardAssetRoot**(): `string`

Defined in: [packages/declarative-hex-worlds/src/runtime/asset-root.ts:75](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/asset-root.ts#L75)

Resolve the consumer’s bootstrap asset root using the documented priority chain. The return value is always a string (never undefined) — callers can always feed it as `bootstrapAssetRoot` to the manifest URL resolver exported from `declarative-hex-worlds/manifest`.

## Returns

[Section titled “Returns”](#returns)

`string`

# resolveGameboardMovementProfile

> **resolveGameboardMovementProfile**(`profile`, `profiles?`): [`GameboardMovementProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementprofile/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:262](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L262)

Resolve a movement profile id or inline profile.

## Parameters

[Section titled “Parameters”](#parameters)

### profile

[Section titled “profile”](#profile)

[`GameboardMovementProfileInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardmovementprofileinput/) | `undefined`

### profiles?

[Section titled “profiles?”](#profiles)

[`GameboardMovementProfileRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementprofileregistry/) = `GAMEBOARD_MOVEMENT_PROFILES`

## Returns

[Section titled “Returns”](#returns)

[`GameboardMovementProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementprofile/)

# resolveGameboardPieceSourceUrl

> **resolveGameboardPieceSourceUrl**(`piece`, `options?`): `string` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:704](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L704)

Resolve a piece source URL from explicit metadata or source-relative metadata.

## Parameters

[Section titled “Parameters”](#parameters)

### piece

[Section titled “piece”](#piece)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

### options?

[Section titled “options?”](#options)

[`GameboardPieceSourceUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecesourceurloptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

`string` | `undefined`

# resolveGameboardPlacementAnimationUrl

> **resolveGameboardPlacementAnimationUrl**(`placement`, `options?`): `string` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:114](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L114)

Resolves a separate animation URL for a placement when the model does not carry the desired clips.

## Parameters

[Section titled “Parameters”](#parameters)

### placement

[Section titled “placement”](#placement)

[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

### options?

[Section titled “options?”](#options)

[`GameboardPlacementAnimationUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementanimationurloptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

`string` | `undefined`

# resolveGameboardPlacementAssetUrl

> **resolveGameboardPlacementAssetUrl**(`placement`, `options?`): `string` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:62](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L62)

Resolves the model URL for a placement from explicit maps, placement metadata, a manifest catalog, or a fallback resolver.

## Parameters

[Section titled “Parameters”](#parameters)

### placement

[Section titled “placement”](#placement)

[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

### options?

[Section titled “options?”](#options)

[`GameboardPlacementAssetUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

`string` | `undefined`

# resolveGameboardScenarioActors

> **resolveGameboardScenarioActors**(`actors?`, `spawnGroups?`): [`ResolvedGameboardScenarioActor`](/declarative-hex-worlds/reference/index/interfaces/resolvedgameboardscenarioactor/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:706](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L706)

Resolves scenario actors against spawn groups without creating entities.

## Parameters

[Section titled “Parameters”](#parameters)

### actors?

[Section titled “actors?”](#actors)

readonly [`GameboardScenarioActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenarioactor/)\[] = `[]`

### spawnGroups?

[Section titled “spawnGroups?”](#spawngroups)

`GameboardSpawnGroupPlan`

## Returns

[Section titled “Returns”](#returns)

[`ResolvedGameboardScenarioActor`](/declarative-hex-worlds/reference/index/interfaces/resolvedgameboardscenarioactor/)\[]

# rotateMask

> **rotateMask**(`mask`, `steps`): `number`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:183](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L183)

Rotates a six-bit hex edge mask clockwise by the requested number of steps.

## Parameters

[Section titled “Parameters”](#parameters)

### mask

[Section titled “mask”](#mask)

`number`

### steps

[Section titled “steps”](#steps)

`number`

## Returns

[Section titled “Returns”](#returns)

`number`

# runGameboardActorTargetInteraction

> **runGameboardActorTargetInteraction**(`world`, `options`, `interactionOptions?`): [`RunGameboardActorTargetInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardactortargetinteractionresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:138](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L138)

Selects an actor target, dispatches the planned command, and then runs systems unless disabled.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### options

[Section titled “options”](#options)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

### interactionOptions?

[Section titled “interactionOptions?”](#interactionoptions)

[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`RunGameboardActorTargetInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardactortargetinteractionresult/)

# runGameboardInteraction

> **runGameboardInteraction**(`world`, `commandOrTarget`, `options?`): [`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:114](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L114)

Dispatches an interaction command and then runs systems unless disabled.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

### options?

[Section titled “options?”](#options)

[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/)

# runGameboardMovementSystem

> **runGameboardMovementSystem**(`world`, `options?`): [`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)\[]

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:412](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L412)

Advance every active movement agent in the world.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### options?

[Section titled “options?”](#options)

[`AdvanceGameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardmovementoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)\[]

# runGameboardPatrolSystem

> **runGameboardPatrolSystem**(`world`, `options?`): [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)\[]

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:235](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L235)

Advance every patrol agent in the world.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### options?

[Section titled “options?”](#options)

[`AdvanceGameboardPatrolOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardpatroloptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)\[]

# runGameboardScenarioSimulation

> **runGameboardScenarioSimulation**(`scenario`, `steps`, `options?`): [`GameboardScenarioSimulationResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationresult/)

Defined in: [packages/declarative-hex-worlds/src/simulation/engine.ts:87](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/engine.ts#L87)

Runs simulation steps against a fresh runtime created from a scenario.

## Parameters

[Section titled “Parameters”](#parameters)

### scenario

[Section titled “scenario”](#scenario)

[`GameboardScenario`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenario/)

### steps

[Section titled “steps”](#steps)

readonly [`GameboardScenarioSimulationStep`](/declarative-hex-worlds/reference/index/type-aliases/gameboardscenariosimulationstep/)\[]

### options?

[Section titled “options?”](#options)

[`RunGameboardScenarioSimulationOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardscenariosimulationoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardScenarioSimulationResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationresult/)

# runGameboardScenarioSimulationScript

> **runGameboardScenarioSimulationScript**(`scenario`, `script`, `options?`): [`GameboardScenarioSimulationResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationresult/)

Defined in: [packages/declarative-hex-worlds/src/simulation/engine.ts:101](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/engine.ts#L101)

Runs an authored simulation script against a fresh runtime created from a scenario, applying script defaults to individual steps.

## Parameters

[Section titled “Parameters”](#parameters)

### scenario

[Section titled “scenario”](#scenario)

[`GameboardScenario`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenario/)

### script

[Section titled “script”](#script)

[`GameboardScenarioSimulationScript`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationscript/)

### options?

[Section titled “options?”](#options)

[`RunGameboardScenarioSimulationOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardscenariosimulationoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardScenarioSimulationResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationresult/)

# runGameboardSystems

> **runGameboardSystems**(`world`, `options?`): [`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/tick.ts:60](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/tick.ts#L60)

Runs the enabled patrol, movement, and quest systems for one game-loop tick.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### options?

[Section titled “options?”](#options)

[`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

# safeParseAssetSourceSpec

> **safeParseAssetSourceSpec**(`input`): `ZodSafeParseResult`<{ `assetRoot`: `string`; `assets`: ({ `biome`: `string`; `edgeMask?`: `number`; `format`: `"png"` | `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"tile"`; } | { `biome?`: `string`; `format`: `"png"`; `grid`: { `cellHeight`: `number`; `cellWidth`: `number`; `cols`: `number`; `rows`: `number`; }; `id`: `string`; `path`: `string`; `role`: `"tileset"`; `transition?`: { `edgeCells`: `Record`<`string`, `number`>; }; } | { `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"png"`; `id`: `string`; `path`: `string`; `role`: `"sprite"`; } | { `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"model"`; })\[]; `name`: `string`; `specVersion`: `1`; }>

Defined in: [packages/declarative-hex-worlds/src/asset-source/spec.ts:163](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/spec.ts#L163)

Non-throwing parse — returns Zod’s `{ success, data | error }` result.

## Parameters

[Section titled “Parameters”](#parameters)

### input

[Section titled “input”](#input)

`unknown`

## Returns

[Section titled “Returns”](#returns)

`ZodSafeParseResult`<{ `assetRoot`: `string`; `assets`: ({ `biome`: `string`; `edgeMask?`: `number`; `format`: `"png"` | `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"tile"`; } | { `biome?`: `string`; `format`: `"png"`; `grid`: { `cellHeight`: `number`; `cellWidth`: `number`; `cols`: `number`; `rows`: `number`; }; `id`: `string`; `path`: `string`; `role`: `"tileset"`; `transition?`: { `edgeCells`: `Record`<`string`, `number`>; }; } | { `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"png"`; `id`: `string`; `path`: `string`; `role`: `"sprite"`; } | { `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"model"`; })\[]; `name`: `string`; `specVersion`: `1`; }>

# safeParseTilesetManifest

> **safeParseTilesetManifest**(`input`): `ZodSafeParseResult`<{ `biomes`: `Record`<`string`, { `select`: `"first"` | `"hash"`; `sheet`: `string`; }>; `kind`: `"tileset"`; `schemaVersion`: `string`; `sheets`: `Record`<`string`, { `edgeCells?`: `Record`<`string`, `number`>; `grid`: { `cellHeight`: `number`; `cellWidth`: `number`; `cols`: `number`; `rows`: `number`; }; `role`: `"transition"` | `"fill"`; `url`: `string`; `variants?`: `number`\[]; }>; }>

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts#L136)

Safe-parse a tileset manifest, returning the Zod result discriminant.

## Parameters

[Section titled “Parameters”](#parameters)

### input

[Section titled “input”](#input)

`unknown`

## Returns

[Section titled “Returns”](#returns)

`ZodSafeParseResult`<{ `biomes`: `Record`<`string`, { `select`: `"first"` | `"hash"`; `sheet`: `string`; }>; `kind`: `"tileset"`; `schemaVersion`: `string`; `sheets`: `Record`<`string`, { `edgeCells?`: `Record`<`string`, `number`>; `grid`: { `cellHeight`: `number`; `cellWidth`: `number`; `cols`: `number`; `rows`: `number`; }; `role`: `"transition"` | `"fill"`; `url`: `string`; `variants?`: `number`\[]; }>; }>

# scanAssetFiles

> **scanAssetFiles**(`files`): [`ScanResult`](/declarative-hex-worlds/reference/index/interfaces/scanresult/)

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:197](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L197)

Classify a scanned file list into candidate assets. A file’s role comes from its top-level directory; its format from its extension. Files under an unknown directory, with an unsupported extension, or whose extension doesn’t fit the role, are skipped.

## Parameters

[Section titled “Parameters”](#parameters)

### files

[Section titled “files”](#files)

readonly [`ScannedFile`](/declarative-hex-worlds/reference/index/interfaces/scannedfile/)\[]

## Returns

[Section titled “Returns”](#returns)

[`ScanResult`](/declarative-hex-worlds/reference/index/interfaces/scanresult/)

# selectCoastVariant

> **selectCoastVariant**(`waterEdges`, `options?`): [`VariantSelection`](/declarative-hex-worlds/reference/types/interfaces/variantselection/)

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:246](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L246)

Selects the coast guide asset and rotation for water-facing edges.

## Parameters

[Section titled “Parameters”](#parameters)

### waterEdges

[Section titled “waterEdges”](#wateredges)

[`HexEdgeInput`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeinput/)

### options?

[Section titled “options?”](#options)

#### waterless?

[Section titled “waterless?”](#waterless)

`boolean`

## Returns

[Section titled “Returns”](#returns)

[`VariantSelection`](/declarative-hex-worlds/reference/types/interfaces/variantselection/)

# selectCoastVariantByLabel

> **selectCoastVariantByLabel**(`label`, `options?`): [`VariantSelection`](/declarative-hex-worlds/reference/types/interfaces/variantselection/)

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:300](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L300)

Selects an unrotated coast guide asset by KayKit label.

## Parameters

[Section titled “Parameters”](#parameters)

### label

[Section titled “label”](#label)

`string`

### options?

[Section titled “options?”](#options)

#### waterless?

[Section titled “waterless?”](#waterless)

`boolean`

## Returns

[Section titled “Returns”](#returns)

[`VariantSelection`](/declarative-hex-worlds/reference/types/interfaces/variantselection/)

# selectGameboardActors

> **selectGameboardActors**(`world`, `options?`): [`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:894](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L894)

Select actors by id, kind, faction, team, tags, tile, radius, hostility, and interaction flags.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### options?

[Section titled “options?”](#options)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

# selectGameboardInteropRelations

> **selectGameboardInteropRelations**(`source`, `filter?`): [`GameboardEcsRelation`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsrelation/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:866](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L866)

Select relations by name, source id, and/or target id.

## Parameters

[Section titled “Parameters”](#parameters)

### source

[Section titled “source”](#source)

[`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/) | [`GameboardInteropSnapshotIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshotindex/)

### filter?

[Section titled “filter?”](#filter)

[`GameboardInteropRelationFilter`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteroprelationfilter/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardEcsRelation`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsrelation/)\[]

# selectGameboardPieces

> **selectGameboardPieces**(`registry`, `selection?`): [`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:530](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L530)

Select pieces from a registry using id, role, source, tag, and EXTRA filters.

## Parameters

[Section titled “Parameters”](#parameters)

### registry

[Section titled “registry”](#registry)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

### selection?

[Section titled “selection?”](#selection)

[`GameboardPieceRegistrySelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryselection/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)\[]

# selectPlacementsByClassifier

> **selectPlacementsByClassifier**(`world`, `tag`): readonly `object`\[]

Defined in: [packages/declarative-hex-worlds/src/classifiers/classifiers-runtime.ts:24](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/classifiers/classifiers-runtime.ts#L24)

All placements in `world` that carry the given classifier tag (in their tag list under the `classifier:` namespace). The renderer-neutral query behind `usePlacementsByClassifier`.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### tag

[Section titled “tag”](#tag)

[`ClassifierTag`](/declarative-hex-worlds/reference/index/type-aliases/classifiertag/)

## Returns

[Section titled “Returns”](#returns)

readonly `object`\[]

# selectRiverCrossingVariant

> **selectRiverCrossingVariant**(`label`, `options?`): [`VariantSelection`](/declarative-hex-worlds/reference/types/interfaces/variantselection/)

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:229](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L229)

Selects one of the river crossing guide variants.

## Parameters

[Section titled “Parameters”](#parameters)

### label

[Section titled “label”](#label)

`"A"` | `"B"`

### options?

[Section titled “options?”](#options)

#### waterless?

[Section titled “waterless?”](#waterless)

`boolean`

## Returns

[Section titled “Returns”](#returns)

[`VariantSelection`](/declarative-hex-worlds/reference/types/interfaces/variantselection/)

# selectRiverVariant

> **selectRiverVariant**(`edges`, `options?`): [`VariantSelection`](/declarative-hex-worlds/reference/types/interfaces/variantselection/)

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:205](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L205)

Selects the river guide asset and rotation for an edge mask.

## Parameters

[Section titled “Parameters”](#parameters)

### edges

[Section titled “edges”](#edges)

[`HexEdgeInput`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeinput/)

### options?

[Section titled “options?”](#options)

#### curvy?

[Section titled “curvy?”](#curvy)

`boolean`

#### waterless?

[Section titled “waterless?”](#waterless)

`boolean`

## Returns

[Section titled “Returns”](#returns)

[`VariantSelection`](/declarative-hex-worlds/reference/types/interfaces/variantselection/)

# selectRiverVariantByLabel

> **selectRiverVariantByLabel**(`label`, `options?`): [`VariantSelection`](/declarative-hex-worlds/reference/types/interfaces/variantselection/)

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:217](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L217)

Selects an unrotated river guide asset by KayKit label.

## Parameters

[Section titled “Parameters”](#parameters)

### label

[Section titled “label”](#label)

`string`

### options?

[Section titled “options?”](#options)

#### curvy?

[Section titled “curvy?”](#curvy)

`boolean`

#### waterless?

[Section titled “waterless?”](#waterless)

`boolean`

## Returns

[Section titled “Returns”](#returns)

[`VariantSelection`](/declarative-hex-worlds/reference/types/interfaces/variantselection/)

# selectRoadVariant

> **selectRoadVariant**(`edges`): [`VariantSelection`](/declarative-hex-worlds/reference/types/interfaces/variantselection/)

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:195](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L195)

Selects the road guide asset and rotation for an edge mask.

## Parameters

[Section titled “Parameters”](#parameters)

### edges

[Section titled “edges”](#edges)

[`HexEdgeInput`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeinput/)

## Returns

[Section titled “Returns”](#returns)

[`VariantSelection`](/declarative-hex-worlds/reference/types/interfaces/variantselection/)

# selectRoadVariantByLabel

> **selectRoadVariantByLabel**(`label`): [`VariantSelection`](/declarative-hex-worlds/reference/types/interfaces/variantselection/)

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:200](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L200)

Selects an unrotated road guide asset by KayKit label.

## Parameters

[Section titled “Parameters”](#parameters)

### label

[Section titled “label”](#label)

`string`

## Returns

[Section titled “Returns”](#returns)

[`VariantSelection`](/declarative-hex-worlds/reference/types/interfaces/variantselection/)

# selectSpawnCoordinates

> **selectSpawnCoordinates**(`options`): [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:299](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L299)

Selects deterministic spawn coordinates that satisfy spacing and passability rules.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`SpawnCoordinateOptions`](/declarative-hex-worlds/reference/index/interfaces/spawncoordinateoptions/)

## Returns

[Section titled “Returns”](#returns)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

# selectTransitionVariant

> **selectTransitionVariant**(`family`, `edges`): [`VariantSelection`](/declarative-hex-worlds/reference/types/interfaces/variantselection/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:143](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L143)

Select the variant covering `edges` for a transition `family`, or `undefined` when the family is unknown or no variant covers the mask (a NON-throwing counterpart to `selectVariant`, for the `AssetSource.resolveEdge` seam where a miss must fall through rather than error). RFC0-9b.

## Parameters

[Section titled “Parameters”](#parameters)

### family

[Section titled “family”](#family)

`string`

### edges

[Section titled “edges”](#edges)

[`HexEdgeInput`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeinput/)

## Returns

[Section titled “Returns”](#returns)

[`VariantSelection`](/declarative-hex-worlds/reference/types/interfaces/variantselection/) | `undefined`

# setGameboardAssetRoot

> **setGameboardAssetRoot**(`assetRoot`): `void`

Defined in: [packages/declarative-hex-worlds/src/runtime/asset-root.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/asset-root.ts#L58)

Set an explicit process-wide asset root. Pass `undefined` to clear the override and fall back to the global / env / default chain.

## Parameters

[Section titled “Parameters”](#parameters)

### assetRoot

[Section titled “assetRoot”](#assetroot)

`string` | `undefined`

## Returns

[Section titled “Returns”](#returns)

`void`

# setGameboardMovementAgent

> **setGameboardMovementAgent**(`world`, `placement`, `options?`): `Entity`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:286](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L286)

Add or update movement-agent state for a placement.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### placement

[Section titled “placement”](#placement)

`string` | `Entity`

### options?

[Section titled “options?”](#options)

[`SetGameboardMovementAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardmovementagentoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

`Entity`

# setGameboardPatrolAgent

> **setGameboardPatrolAgent**(`world`, `placement`, `options`): `Entity`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:163](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L163)

Attach a patrol route to a placement or actor.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### placement

[Section titled “placement”](#placement)

`string` | `Entity`

### options

[Section titled “options”](#options)

[`SetGameboardPatrolAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardpatrolagentoptions/)

## Returns

[Section titled “Returns”](#returns)

`Entity`

# snapshotGameboardSystemEvent

> **snapshotGameboardSystemEvent**(`event`): [`GameboardSystemEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardsystemeventrecord/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:352](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L352)

Converts one in-memory system event into a serializable event record.

## Parameters

[Section titled “Parameters”](#parameters)

### event

[Section titled “event”](#event)

[`GameboardSystemEvent`](/declarative-hex-worlds/reference/index/type-aliases/gameboardsystemevent/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardSystemEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardsystemeventrecord/)

# snapshotGameboardSystemEvents

> **snapshotGameboardSystemEvents**(`events`): [`GameboardSystemEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardsystemeventrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:418](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L418)

Converts in-memory system events into serializable records.

## Parameters

[Section titled “Parameters”](#parameters)

### events

[Section titled “events”](#events)

readonly [`GameboardSystemEvent`](/declarative-hex-worlds/reference/index/type-aliases/gameboardsystemevent/)\[]

## Returns

[Section titled “Returns”](#returns)

[`GameboardSystemEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardsystemeventrecord/)\[]

# spawnGameboardActor

> **spawnGameboardActor**(`world`, `options`): `Entity`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:752](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L752)

Spawn a placement and immediately register it as a gameplay actor.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### options

[Section titled “options”](#options)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/)

## Returns

[Section titled “Returns”](#returns)

`Entity`

# spawnGameboardLayoutFill

> **spawnGameboardLayoutFill**(`world`, `options`): `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout-runtime.ts:57](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout-runtime.ts#L57)

Spawn all placements generated by a layout fill pass into a Koota world.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### options

[Section titled “options”](#options)

[`GameboardLayoutFillOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfilloptions/)

## Returns

[Section titled “Returns”](#returns)

`Entity`\[]

# spawnGameboardLayoutPlacements

> **spawnGameboardLayoutPlacements**(`world`, `options`): `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout-runtime.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout-runtime.ts#L47)

Spawn generated layout placements into a Koota world.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### options

[Section titled “options”](#options)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/)

## Returns

[Section titled “Returns”](#returns)

`Entity`\[]

# spawnGameboardPlacement

> **spawnGameboardPlacement**(`world`, `options`): `Entity`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:468](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L468)

Spawn one runtime placement on an existing tile, deriving world position, layer defaults, EXTRA detection, and occupancy footprint relations.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### options

[Section titled “options”](#options)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)

## Returns

[Section titled “Returns”](#returns)

`Entity`

# spawnGameboardPlan

> **spawnGameboardPlan**(`world`, `plan`): [`GameboardEntityIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardentityindex/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:410](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L410)

Clear the world and spawn all tiles, placements, marker traits, adjacency relations, and occupancy relations for a generated board plan.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardEntityIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardentityindex/)

# spawnGameboardQuest

> **spawnGameboardQuest**(`world`, `definition`, `options?`): `Entity`

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:186](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L186)

Spawn a quest entity into a Koota world.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### definition

[Section titled “definition”](#definition)

[`GameboardQuestDefinition`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestdefinition/)

### options?

[Section titled “options?”](#options)

[`SpawnGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardquestoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

`Entity`

# stripAssetCategory

> **stripAssetCategory**(`asset`): { `biome`: `string`; `edgeMask?`: `number`; `format`: `"png"` | `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"tile"`; } | { `biome?`: `string`; `format`: `"png"`; `grid`: { `cellHeight`: `number`; `cellWidth`: `number`; `cols`: `number`; `rows`: `number`; }; `id`: `string`; `path`: `string`; `role`: `"tileset"`; `transition?`: { `edgeCells`: `Record`<`string`, `number`>; }; } | { `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"png"`; `id`: `string`; `path`: `string`; `role`: `"sprite"`; } | { `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"model"`; }

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:179](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L179)

Return a copy of an asset with any `category` field removed. Used by the `init` and `web` authoring flows when the developer clears a suggested gameplay category (choosing “none”).

## Parameters

[Section titled “Parameters”](#parameters)

### asset

[Section titled “asset”](#asset)

{ `biome`: `string`; `edgeMask?`: `number`; `format`: `"png"` | `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"tile"`; } | { `biome?`: `string`; `format`: `"png"`; `grid`: { `cellHeight`: `number`; `cellWidth`: `number`; `cols`: `number`; `rows`: `number`; }; `id`: `string`; `path`: `string`; `role`: `"tileset"`; `transition?`: { `edgeCells`: `Record`<`string`, `number`>; }; } | { `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"png"`; `id`: `string`; `path`: `string`; `role`: `"sprite"`; } | { `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"model"`; }

#### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `biome`: `string`; `edgeMask?`: `number`; `format`: `"png"` | `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"tile"`; }

##### biome

[Section titled “biome”](#biome)

`string` = `...`

Biome/terrain key this tile represents (grass, water, desert, …).

##### edgeMask?

[Section titled “edgeMask?”](#edgemask)

`number` = `...`

Optional edge mask this tile satisfies, for transition tiles (G3).

##### format

[Section titled “format”](#format)

`"png"` | `"glb"` | `"gltf"` = `...`

##### id

[Section titled “id”](#id)

`string` = `idSchema`

##### path

[Section titled “path”](#path)

`string` = `pathSchema`

##### role

[Section titled “role”](#role)

`"tile"` = `...`

***

#### Type Literal

[Section titled “Type Literal”](#type-literal-1)

{ `biome?`: `string`; `format`: `"png"`; `grid`: { `cellHeight`: `number`; `cellWidth`: `number`; `cols`: `number`; `rows`: `number`; }; `id`: `string`; `path`: `string`; `role`: `"tileset"`; `transition?`: { `edgeCells`: `Record`<`string`, `number`>; }; }

##### biome?

[Section titled “biome?”](#biome-1)

`string` = `...`

Optional biome this whole sheet represents (fill sheets).

##### format

[Section titled “format”](#format-1)

`"png"` = `...`

##### grid

[Section titled “grid”](#grid)

{ `cellHeight`: `number`; `cellWidth`: `number`; `cols`: `number`; `rows`: `number`; } = `gridSchema`

##### grid.cellHeight

[Section titled “grid.cellHeight”](#gridcellheight)

`number` = `...`

##### grid.cellWidth

[Section titled “grid.cellWidth”](#gridcellwidth)

`number` = `...`

##### grid.cols

[Section titled “grid.cols”](#gridcols)

`number` = `...`

##### grid.rows

[Section titled “grid.rows”](#gridrows)

`number` = `...`

##### id

[Section titled “id”](#id-1)

`string` = `idSchema`

##### path

[Section titled “path”](#path-1)

`string` = `pathSchema`

##### role

[Section titled “role”](#role-1)

`"tileset"` = `...`

##### transition?

[Section titled “transition?”](#transition)

{ `edgeCells`: `Record`<`string`, `number`>; } = `...`

Optional per-cell role: ‘fill’ cells are interchangeable variations; ‘transition’ cells map an edge mask to a specific cell index (G3).

##### transition.edgeCells

[Section titled “transition.edgeCells”](#transitionedgecells)

`Record`<`string`, `number`> = `...`

Canonical edge mask → cell index within the sheet grid.

***

#### Type Literal

[Section titled “Type Literal”](#type-literal-2)

{ `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"png"`; `id`: `string`; `path`: `string`; `role`: `"sprite"`; }

##### category?

[Section titled “category?”](#category)

`"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"` = `...`

Suggested gameplay category (unit/pc/npc/enemy/…); a default the dev may override.

##### format

[Section titled “format”](#format-2)

`"png"` = `...`

##### id

[Section titled “id”](#id-2)

`string` = `idSchema`

##### path

[Section titled “path”](#path-2)

`string` = `pathSchema`

##### role

[Section titled “role”](#role-2)

`"sprite"` = `...`

***

#### Type Literal

[Section titled “Type Literal”](#type-literal-3)

{ `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"model"`; }

##### category?

[Section titled “category?”](#category-1)

`"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"` = `...`

Suggested gameplay category (unit/pc/npc/enemy/…); a default the dev may override.

##### format

[Section titled “format”](#format-3)

`"glb"` | `"gltf"` = `...`

##### id

[Section titled “id”](#id-3)

`string` = `idSchema`

##### path

[Section titled “path”](#path-3)

`string` = `pathSchema`

##### role

[Section titled “role”](#role-3)

`"model"` = `...`

## Returns

[Section titled “Returns”](#returns)

### Type Literal

[Section titled “Type Literal”](#type-literal-4)

{ `biome`: `string`; `edgeMask?`: `number`; `format`: `"png"` | `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"tile"`; }

#### biome

[Section titled “biome”](#biome-2)

> **biome**: `string`

Biome/terrain key this tile represents (grass, water, desert, …).

#### edgeMask?

[Section titled “edgeMask?”](#edgemask-1)

> `optional` **edgeMask?**: `number`

Optional edge mask this tile satisfies, for transition tiles (G3).

#### format

[Section titled “format”](#format-4)

> **format**: `"png"` | `"glb"` | `"gltf"`

#### id

[Section titled “id”](#id-4)

> **id**: `string` = `idSchema`

#### path

[Section titled “path”](#path-4)

> **path**: `string` = `pathSchema`

#### role

[Section titled “role”](#role-4)

> **role**: `"tile"`

***

### Type Literal

[Section titled “Type Literal”](#type-literal-5)

{ `biome?`: `string`; `format`: `"png"`; `grid`: { `cellHeight`: `number`; `cellWidth`: `number`; `cols`: `number`; `rows`: `number`; }; `id`: `string`; `path`: `string`; `role`: `"tileset"`; `transition?`: { `edgeCells`: `Record`<`string`, `number`>; }; }

#### biome?

[Section titled “biome?”](#biome-3)

> `optional` **biome?**: `string`

Optional biome this whole sheet represents (fill sheets).

#### format

[Section titled “format”](#format-5)

> **format**: `"png"`

#### grid

[Section titled “grid”](#grid-1)

> **grid**: `object` = `gridSchema`

##### grid.cellHeight

[Section titled “grid.cellHeight”](#gridcellheight-1)

> **cellHeight**: `number`

##### grid.cellWidth

[Section titled “grid.cellWidth”](#gridcellwidth-1)

> **cellWidth**: `number`

##### grid.cols

[Section titled “grid.cols”](#gridcols-1)

> **cols**: `number`

##### grid.rows

[Section titled “grid.rows”](#gridrows-1)

> **rows**: `number`

#### id

[Section titled “id”](#id-5)

> **id**: `string` = `idSchema`

#### path

[Section titled “path”](#path-5)

> **path**: `string` = `pathSchema`

#### role

[Section titled “role”](#role-5)

> **role**: `"tileset"`

#### transition?

[Section titled “transition?”](#transition-1)

> `optional` **transition?**: `object`

Optional per-cell role: ‘fill’ cells are interchangeable variations; ‘transition’ cells map an edge mask to a specific cell index (G3).

##### transition.edgeCells

[Section titled “transition.edgeCells”](#transitionedgecells-1)

> **edgeCells**: `Record`<`string`, `number`>

Canonical edge mask → cell index within the sheet grid.

***

### Type Literal

[Section titled “Type Literal”](#type-literal-6)

{ `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"png"`; `id`: `string`; `path`: `string`; `role`: `"sprite"`; }

#### category?

[Section titled “category?”](#category-2)

> `optional` **category?**: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`

Suggested gameplay category (unit/pc/npc/enemy/…); a default the dev may override.

#### format

[Section titled “format”](#format-6)

> **format**: `"png"`

#### id

[Section titled “id”](#id-6)

> **id**: `string` = `idSchema`

#### path

[Section titled “path”](#path-6)

> **path**: `string` = `pathSchema`

#### role

[Section titled “role”](#role-6)

> **role**: `"sprite"`

***

### Type Literal

[Section titled “Type Literal”](#type-literal-7)

{ `category?`: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`; `format`: `"glb"` | `"gltf"`; `id`: `string`; `path`: `string`; `role`: `"model"`; }

#### category?

[Section titled “category?”](#category-3)

> `optional` **category?**: `"unit"` | `"prop"` | `"structure"` | `"npc"` | `"enemy"` | `"pc"` | `"encounter"`

Suggested gameplay category (unit/pc/npc/enemy/…); a default the dev may override.

#### format

[Section titled “format”](#format-7)

> **format**: `"glb"` | `"gltf"`

#### id

[Section titled “id”](#id-7)

> **id**: `string` = `idSchema`

#### path

[Section titled “path”](#path-7)

> **path**: `string` = `pathSchema`

#### role

[Section titled “role”](#role-7)

> **role**: `"model"`

# summarizeGameboardPlan

> **summarizeGameboardPlan**(`plan`, `options?`): [`GameboardPlanSummary`](/declarative-hex-worlds/reference/index/interfaces/gameboardplansummary/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:711](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L711)

Summarize terrain, elevation, placement, feature, and local-only asset usage in a generated or live-projected gameboard plan.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### options?

[Section titled “options?”](#options)

[`SummarizeGameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/summarizegameboardplanoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlanSummary`](/declarative-hex-worlds/reference/index/interfaces/gameboardplansummary/)

# summarizeGameboardScenario

> **summarizeGameboardScenario**(`scenario`, `options?`): [`GameboardScenarioSummary`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosummary/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:455](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L455)

Summarizes playable scenario content without creating a live Koota world.

## Parameters

[Section titled “Parameters”](#parameters)

### scenario

[Section titled “scenario”](#scenario)

[`GameboardScenario`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenario/)

### options?

[Section titled “options?”](#options)

[`SummarizeGameboardScenarioOptions`](/declarative-hex-worlds/reference/index/interfaces/summarizegameboardscenariooptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardScenarioSummary`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosummary/)

# tilesetHexGeometry

> **tilesetHexGeometry**(`manifest`, `grid?`): `object`

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset.ts:68](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset.ts#L68)

Derive the board PLACEMENT geometry a tileset needs for seamless quad tessellation, from the manifest’s cell aspect. Pass the result to `<HexWorld geometry>` (or `projectWorldToGameboardPlan({ geometry })`).

Why row spacing must change: a full-cell quad’s Z-extent is `height = width · cellHeight/cellWidth` (the baked cell aspect). For pointy-top quads to interlock, adjacent ROWS must be `height/2` apart. `rowSpacingForGeometry` computes `1.5·(depth/2)`, so we invert: `depth = (height/2)/0.75 = (2/3)·height`. The default regular-hex depth (≈2.3094) spreads rows \~3× too far in Z, leaving the blue gaps between tiles. Width + elevationStep stay at the board defaults.

Uses the first sheet’s grid for the aspect (all sheets in a coherent pack share a cell size); pass a specific `grid` to override.

## Parameters

[Section titled “Parameters”](#parameters)

### manifest

[Section titled “manifest”](#manifest)

#### biomes

[Section titled “biomes”](#biomes)

`Record`<`string`, { `select`: `"first"` | `"hash"`; `sheet`: `string`; }> = `...`

#### kind

[Section titled “kind”](#kind)

`"tileset"` = `...`

#### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

`string` = `...`

#### sheets

[Section titled “sheets”](#sheets)

`Record`<`string`, { `edgeCells?`: `Record`<`string`, `number`>; `grid`: { `cellHeight`: `number`; `cellWidth`: `number`; `cols`: `number`; `rows`: `number`; }; `role`: `"transition"` | `"fill"`; `url`: `string`; `variants?`: `number`\[]; }> = `...`

### grid?

[Section titled “grid?”](#grid)

#### cellHeight

[Section titled “cellHeight”](#cellheight)

`number` = `...`

#### cellWidth

[Section titled “cellWidth”](#cellwidth)

`number` = `...`

#### cols

[Section titled “cols”](#cols)

`number` = `...`

#### rows

[Section titled “rows”](#rows)

`number` = `...`

## Returns

[Section titled “Returns”](#returns)

`object`

### depth

[Section titled “depth”](#depth)

> **depth**: `number`

### elevationStep

[Section titled “elevationStep”](#elevationstep)

> **elevationStep**: `number`

### width

[Section titled “width”](#width)

> **width**: `number`

# transformForHex

> **transformForHex**(`coordinates`, `options?`): [`AssetTransform`](/declarative-hex-worlds/reference/index/interfaces/assettransform/)

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:133](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L133)

Creates a transform from axial coordinates, optional elevation, and optional placement offset.

## Parameters

[Section titled “Parameters”](#parameters)

### coordinates

[Section titled “coordinates”](#coordinates)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### options?

[Section titled “options?”](#options)

#### elevation?

[Section titled “elevation?”](#elevation)

`number`

#### positionOffset?

[Section titled “positionOffset?”](#positionoffset)

[`GameboardPlacementPositionOffset`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementpositionoffset/)

#### rotationY?

[Section titled “rotationY?”](#rotationy)

`number`

#### scale?

[Section titled “scale?”](#scale)

`number`

## Returns

[Section titled “Returns”](#returns)

[`AssetTransform`](/declarative-hex-worlds/reference/index/interfaces/assettransform/)

# transformForPlacement

> **transformForPlacement**(`placement`): [`AssetTransform`](/declarative-hex-worlds/reference/index/interfaces/assettransform/)

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:176](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L176)

Converts a serialized placement into a gameboard transform.

## Parameters

[Section titled “Parameters”](#parameters)

### placement

[Section titled “placement”](#placement)

[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

## Returns

[Section titled “Returns”](#returns)

[`AssetTransform`](/declarative-hex-worlds/reference/index/interfaces/assettransform/)

# transformForVariant

> **transformForVariant**(`coordinates`, `variant`, `options?`): [`AssetTransform`](/declarative-hex-worlds/reference/index/interfaces/assettransform/)

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:158](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L158)

Creates a transform from axial coordinates and a selected road/river/coast variant rotation.

## Parameters

[Section titled “Parameters”](#parameters)

### coordinates

[Section titled “coordinates”](#coordinates)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### variant

[Section titled “variant”](#variant)

[`VariantSelection`](/declarative-hex-worlds/reference/types/interfaces/variantselection/)

### options?

[Section titled “options?”](#options)

#### elevation?

[Section titled “elevation?”](#elevation)

`number`

#### positionOffset?

[Section titled “positionOffset?”](#positionoffset)

[`GameboardPlacementPositionOffset`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementpositionoffset/)

#### scale?

[Section titled “scale?”](#scale)

`number`

## Returns

[Section titled “Returns”](#returns)

[`AssetTransform`](/declarative-hex-worlds/reference/index/interfaces/assettransform/)

# tryParseHexKey

> **tryParseHexKey**(`key`): [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:96](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L96)

Non-throwing variant of [parseHexKey](/declarative-hex-worlds/reference/index/functions/parsehexkey/). Returns `undefined` when the key is malformed. Use this on lookup paths where a miss is expected; use [parseHexKey](/declarative-hex-worlds/reference/index/functions/parsehexkey/) on assertion paths where a miss is a programming error.

## Parameters

[Section titled “Parameters”](#parameters)

### key

[Section titled “key”](#key)

`string`

## Returns

[Section titled “Returns”](#returns)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/) | `undefined`

# updateGameboardActor

> **updateGameboardActor**(`world`, `actor`, `options`): `Entity`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:811](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L811)

Update actor state while keeping omitted fields stable and mirroring actor metadata back onto the placement metadata.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### actor

[Section titled “actor”](#actor)

`string` | `Entity`

### options

[Section titled “options”](#options)

[`UpdateGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardactoroptions/)

## Returns

[Section titled “Returns”](#returns)

`Entity`

# updateGameboardPlacement

> **updateGameboardPlacement**(`world`, `placement`, `options`): `Entity`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:496](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L496)

Mutate an existing placement while keeping unspecified placement state stable. Position, tile relations, marker traits, and occupancy footprint relations are synchronized after the update.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### placement

[Section titled “placement”](#placement)

`string` | `Entity`

### options

[Section titled “options”](#options)

[`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/)

## Returns

[Section titled “Returns”](#returns)

`Entity`

# validateAccessoryAttachments

> **validateAccessoryAttachments**(`attachments`): readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/accessories/accessories.ts:70](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/accessories/accessories.ts#L70)

Validate a set of accessory attachments: ids unique, node + assetId non-empty. Returns the list of problems (empty = valid) so callers can fail at author time rather than silently drop a mis-specified accessory during rendering.

## Parameters

[Section titled “Parameters”](#parameters)

### attachments

[Section titled “attachments”](#attachments)

readonly [`AccessoryAttachment`](/declarative-hex-worlds/reference/index/interfaces/accessoryattachment/)\[]

## Returns

[Section titled “Returns”](#returns)

readonly `string`\[]

# validateGameboardScenario

> **validateGameboardScenario**(`scenario`, `config?`): [`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:353](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L353)

Validates a scenario and returns all scenario/plan rule violations.

## Parameters

[Section titled “Parameters”](#parameters)

### scenario

[Section titled “scenario”](#scenario)

[`GameboardScenario`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenario/)

### config?

[Section titled “config?”](#config)

[`GameboardScenarioValidationConfig`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariovalidationconfig/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

# validateGameboardScenarioSimulationScript

> **validateGameboardScenarioSimulationScript**(`script`, `config?`): [`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-validators.ts:114](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-validators.ts#L114)

Returns validation violations for a simulation script.

## Parameters

[Section titled “Parameters”](#parameters)

### script

[Section titled “script”](#script)

[`GameboardScenarioSimulationScript`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationscript/)

### config?

[Section titled “config?”](#config)

[`GameboardScenarioSimulationScriptValidationConfig`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationscriptvalidationconfig/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

# validateTextureBindings

> **validateTextureBindings**(`bindings`): readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts:53](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts#L53)

Validate texture bindings at author time: assetId + textureUrl non-empty. Returns the problems (empty = valid) so a mis-specified binding fails before it silently no-ops at render.

## Parameters

[Section titled “Parameters”](#parameters)

### bindings

[Section titled “bindings”](#bindings)

readonly [`TextureBinding`](/declarative-hex-worlds/reference/index/interfaces/texturebinding/)\[]

## Returns

[Section titled “Returns”](#returns)

readonly `string`\[]

# AccessoryAttachment

Defined in: [packages/declarative-hex-worlds/src/accessories/accessories.ts:25](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/accessories/accessories.ts#L25)

An accessory attached to a character model at a named node/bone.

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> `readonly` **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/accessories/accessories.ts:29](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/accessories/accessories.ts#L29)

Asset id of the accessory model (resolved through the normal asset source).

***

### id

[Section titled “id”](#id)

> `readonly` **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/accessories/accessories.ts:27](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/accessories/accessories.ts#L27)

Stable id for this attachment (for diffing/removal).

***

### node

[Section titled “node”](#node)

> `readonly` **node**: `string`

Defined in: [packages/declarative-hex-worlds/src/accessories/accessories.ts:34](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/accessories/accessories.ts#L34)

Name of the target node/bone in the character’s skeleton (e.g. `Head`, `HandR`). The three binding looks this up via `getObjectByName`.

***

### transform?

[Section titled “transform?”](#transform)

> `readonly` `optional` **transform?**: [`AccessoryLocalTransform`](/declarative-hex-worlds/reference/index/interfaces/accessorylocaltransform/)

Defined in: [packages/declarative-hex-worlds/src/accessories/accessories.ts:36](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/accessories/accessories.ts#L36)

Local transform relative to the attachment node.

# AccessoryLocalTransform

Defined in: [packages/declarative-hex-worlds/src/accessories/accessories.ts:15](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/accessories/accessories.ts#L15)

A local transform applied to an accessory relative to its attachment node.

## Properties

[Section titled “Properties”](#properties)

### position?

[Section titled “position?”](#position)

> `readonly` `optional` **position?**: `Partial`<[`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)>

Defined in: [packages/declarative-hex-worlds/src/accessories/accessories.ts:17](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/accessories/accessories.ts#L17)

Local position offset from the node origin (default 0,0,0).

***

### rotation?

[Section titled “rotation?”](#rotation)

> `readonly` `optional` **rotation?**: `Partial`<[`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)>

Defined in: [packages/declarative-hex-worlds/src/accessories/accessories.ts:19](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/accessories/accessories.ts#L19)

Local Euler rotation in radians (default 0,0,0).

***

### scale?

[Section titled “scale?”](#scale)

> `readonly` `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/accessories/accessories.ts:21](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/accessories/accessories.ts#L21)

Local uniform scale (default 1).

# AdvanceGameboardMovementOptions

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:109](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L109)

Options for advancing movement.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/)

## Properties

[Section titled “Properties”](#properties)

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:85](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L85)

Placement ids ignored during pathing.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/).[`ignorePlacementIds`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/#ignoreplacementids)

***

### movementBudget?

[Section titled “movementBudget?”](#movementbudget)

> `optional` **movementBudget?**: `number`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:83](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L83)

Movement budget override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/).[`movementBudget`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/#movementbudget)

***

### navigation?

[Section titled “navigation?”](#navigation)

> `optional` **navigation?**: [`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:87](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L87)

Navigation profile overrides merged over the movement profile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/).[`navigation`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/#navigation)

***

### profile?

[Section titled “profile?”](#profile)

> `optional` **profile?**: [`GameboardMovementProfileInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardmovementprofileinput/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:79](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L79)

Movement profile id or inline profile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/).[`profile`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/#profile)

***

### profiles?

[Section titled “profiles?”](#profiles)

> `optional` **profiles?**: [`GameboardMovementProfileRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementprofileregistry/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:81](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L81)

Registry used to resolve profile ids.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/).[`profiles`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/#profiles)

***

### steps?

[Section titled “steps?”](#steps)

> `optional` **steps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:111](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L111)

Number of path steps to advance. Defaults to `1`.

# AdvanceGameboardPatrolOptions

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:73](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L73)

Options for advancing patrol agents.

## Properties

[Section titled “Properties”](#properties)

### deactivateOnBlocked?

[Section titled “deactivateOnBlocked?”](#deactivateonblocked)

> `optional` **deactivateOnBlocked?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:79](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L79)

Deactivate the patrol when movement is blocked.

***

### movement?

[Section titled “movement?”](#movement)

> `optional` **movement?**: [`GameboardMovementPathRequestOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementpathrequestoptions/)

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:75](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L75)

Movement options used when requesting segment movement.

***

### resetMovementBudget?

[Section titled “resetMovementBudget?”](#resetmovementbudget)

> `optional` **resetMovementBudget?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:77](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L77)

Reset movement budget before each patrol segment request.

# AdvanceGameboardQuestOptions

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:102](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L102)

Options for advancing quest state.

## Properties

[Section titled “Properties”](#properties)

### advanceThroughCompleted?

[Section titled “advanceThroughCompleted?”](#advancethroughcompleted)

> `optional` **advanceThroughCompleted?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:104](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L104)

Continue through completed objectives in one advance call.

***

### step?

[Section titled “step?”](#step)

> `optional` **step?**: `number`

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:106](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L106)

Current simulation/system step.

# AnalyzeGameboardPieceRegistryOptions

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:207](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L207)

Options for analyzing a piece registry.

## Properties

[Section titled “Properties”](#properties)

### checks?

[Section titled “checks?”](#checks)

> `optional` **checks?**: readonly [`GameboardPieceRegistryAnalysisCheckInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryanalysischeckinput/)\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:209](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L209)

Optional checks to run against the registry.

# AssetSource

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:203](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L203)

The resolution contract. An implementation turns a placement (and, for transition tiles, an edge mask) into an `AssetRenderRequest` the render bridge understands — or `undefined` when this source can’t resolve it (letting a caller fall through to another source or a default).

## Properties

[Section titled “Properties”](#properties)

### kind

[Section titled “kind”](#kind)

> `readonly` **kind**: `string` & `object` | `"tileset"` | `"gltf-pack"`

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:205](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L205)

Source kind. Built-ins: `'gltf-pack'`, `'tileset'`. Open for extension.

## Methods

[Section titled “Methods”](#methods)

### resolve()

[Section titled “resolve()”](#resolve)

> **resolve**(`placement`, `ctx?`): [`AssetRenderRequest`](/declarative-hex-worlds/reference/index/type-aliases/assetrenderrequest/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:207](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L207)

Resolve a placement to a render request.

#### Parameters

[Section titled “Parameters”](#parameters)

##### placement

[Section titled “placement”](#placement)

[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

##### ctx?

[Section titled “ctx?”](#ctx)

[`ResolveContext`](/declarative-hex-worlds/reference/index/interfaces/resolvecontext/)

#### Returns

[Section titled “Returns”](#returns)

[`AssetRenderRequest`](/declarative-hex-worlds/reference/index/type-aliases/assetrenderrequest/) | `undefined`

***

### resolveEdge()?

[Section titled “resolveEdge()?”](#resolveedge)

> `optional` **resolveEdge**(`assetId`, `edgeMask`, `ctx?`): [`AssetRenderRequest`](/declarative-hex-worlds/reference/index/type-aliases/assetrenderrequest/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:213](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L213)

Optional: resolve a transition tile’s edge mask to a concrete cell/variant (G3). A GLTF pack returns a coast-model URL; a tileset returns a positional cell. Sources without positional transitions omit this.

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### assetId

[Section titled “assetId”](#assetid)

`string`

##### edgeMask

[Section titled “edgeMask”](#edgemask)

`number`

##### ctx?

[Section titled “ctx?”](#ctx-1)

[`ResolveContext`](/declarative-hex-worlds/reference/index/interfaces/resolvecontext/)

#### Returns

[Section titled “Returns”](#returns-1)

[`AssetRenderRequest`](/declarative-hex-worlds/reference/index/type-aliases/assetrenderrequest/) | `undefined`

# AssetTint

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:78](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L78)

A multiplicative RGB tint applied to a rendered placement. Each channel is in `[0, 1]`; white (`{ r: 1, g: 1, b: 1 }`) is the identity (no change). Because it multiplies the sampled texel colour, it lets a consuming GAME shade a shared tileset atlas per placement WITHOUT re-authoring art:

* fog-of-war: dim explored-but-unseen tiles toward grey (`{r:.5,g:.5,b:.5}`);
* season: warm autumn (`{r:1,g:.85,b:.6}`) or cool winter wash over the board;
* team/ownership: tint a captured tile toward the owner’s colour. The tint is a render concern — the sim stores the intent, the binding applies it to the material’s `color`, and the same atlas serves every shading state.

## Properties

[Section titled “Properties”](#properties)

### b

[Section titled “b”](#b)

> **b**: `number`

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:84](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L84)

Blue channel multiplier, `[0, 1]`.

***

### g

[Section titled “g”](#g)

> **g**: `number`

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:82](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L82)

Green channel multiplier, `[0, 1]`.

***

### r

[Section titled “r”](#r)

> **r**: `number`

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:80](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L80)

Red channel multiplier, `[0, 1]`.

# AssetTransform

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:38](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L38)

Render transform for a placement, in world space. Neutral of any renderer (moved here from `src/three` for RFC0-RENDER so the render-request contract is backend-agnostic). A 3D backend uses the full x/y/z + rotationY; a 2D backend projects to screen space and treats the depth axis as z-order.

## Properties

[Section titled “Properties”](#properties)

### position

[Section titled “position”](#position)

> **position**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:40](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L40)

World-space position for the object origin.

***

### rotationY

[Section titled “rotationY”](#rotationy)

> **rotationY**: `number`

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:42](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L42)

Y-axis rotation in radians (the board-plane rotation both 2D and 3D share).

***

### scale

[Section titled “scale”](#scale)

> **scale**: `number`

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:44](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L44)

Uniform scale.

# BoardBounds

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:18](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L18)

Axis-aligned world-space bounds of a board (over the board plane + elevation).

## Properties

[Section titled “Properties”](#properties)

### center

[Section titled “center”](#center)

> `readonly` **center**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:22](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L22)

Center of the bounds — the natural look-at target.

***

### max

[Section titled “max”](#max)

> `readonly` **max**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:20](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L20)

***

### min

[Section titled “min”](#min)

> `readonly` **min**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:19](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L19)

***

### size

[Section titled “size”](#size)

> `readonly` **size**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:24](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L24)

Full extent along each axis (max - min).

# BridgeOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:452](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L452)

Options for adding a neutral bridge structure.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`AddBridgeRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addbridgerecipestep/)

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:454](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L454)

Tile where the bridge is anchored, usually a road crossing over water or river terrain.

***

### facing?

[Section titled “facing?”](#facing)

> `optional` **facing?**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:458](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L458)

Edge the bridge points toward; also used as the default rotation.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:460](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L460)

Clockwise 60-degree rotation steps. Overrides `facing` when provided.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:462](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L462)

Uniform render scale.

***

### variant?

[Section titled “variant?”](#variant)

> `optional` **variant?**: [`BridgeVariant`](/declarative-hex-worlds/reference/index/type-aliases/bridgevariant/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:456](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L456)

KayKit bridge visual variant. Defaults to `A`.

# CameraFraming

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L65)

A computed camera framing — renderer-neutral. A binding applies it to its camera.

## Properties

[Section titled “Properties”](#properties)

### distance

[Section titled “distance”](#distance)

> `readonly` **distance**: `number`

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:80](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L80)

Distance from eye to target.

***

### fov

[Section titled “fov”](#fov)

> `readonly` **fov**: `number`

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:78](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L78)

Field of view in radians (perspective).

***

### orthoHalfHeight

[Section titled “orthoHalfHeight”](#orthohalfheight)

> `readonly` **orthoHalfHeight**: `number`

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:76](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L76)

Half-height of the orthographic view volume (world units). The binding derives the ortho box from this + the viewport aspect. Present for both projections so a binding can frame consistently; ignored by a pure-perspective camera.

***

### position

[Section titled “position”](#position)

> `readonly` **position**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L67)

Eye position in world space.

***

### projection

[Section titled “projection”](#projection)

> `readonly` **projection**: [`CameraProjection`](/declarative-hex-worlds/reference/index/type-aliases/cameraprojection/)

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:70](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L70)

***

### target

[Section titled “target”](#target)

> `readonly` **target**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:69](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L69)

Look-at target (board center).

# CameraState

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L47)

A requested camera view — the SIGNAL a renderer binding subscribes to.

## Properties

[Section titled “Properties”](#properties)

### angle

[Section titled “angle”](#angle)

> `readonly` **angle**: [`CameraAngle`](/declarative-hex-worlds/reference/index/type-aliases/cameraangle/)

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:48](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L48)

***

### fit

[Section titled “fit”](#fit)

> `readonly` **fit**: [`CameraFit`](/declarative-hex-worlds/reference/index/type-aliases/camerafit/)

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:50](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L50)

***

### fov?

[Section titled “fov?”](#fov)

> `readonly` `optional` **fov?**: `number`

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:54](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L54)

Field of view in radians for perspective projection (default \~50°).

***

### padding?

[Section titled “padding?”](#padding)

> `readonly` `optional` **padding?**: `number`

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:52](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L52)

Fraction of extra room around the board for `frame-board` (default 0.15).

***

### projection

[Section titled “projection”](#projection)

> `readonly` **projection**: [`CameraProjection`](/declarative-hex-worlds/reference/index/type-aliases/cameraprojection/)

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:49](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L49)

# CanonicalVariant

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:11](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L11)

Canonical guide asset variant before rotation and waterless/curvy modifiers.

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:15](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L15)

Manifest asset id for the unrotated canonical variant.

***

### canonicalMask

[Section titled “canonicalMask”](#canonicalmask)

> **canonicalMask**: `number`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:17](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L17)

Six-bit edge mask represented by the canonical orientation.

***

### label

[Section titled “label”](#label)

> **label**: `string`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:13](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L13)

KayKit guide label, such as `A` or `crossing_A`.

# CellRect

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:51](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L51)

A rectangular sub-region of a sprite/tile sheet, in pixels. The origin is the sheet’s top-left; `x`/`y` locate the cell’s top-left corner.

## Properties

[Section titled “Properties”](#properties)

### height

[Section titled “height”](#height)

> **height**: `number`

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:55](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L55)

***

### width

[Section titled “width”](#width)

> **width**: `number`

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:54](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L54)

***

### x

[Section titled “x”](#x)

> **x**: `number`

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:52](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L52)

***

### y

[Section titled “y”](#y)

> **y**: `number`

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:53](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L53)

# ConstructionSiteOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:512](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L512)

Options for adding construction, ruin, and worksite neutral structures.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`AddConstructionSiteRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addconstructionsiterecipestep/)

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:514](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L514)

Tile where the construction asset is anchored.

***

### constructionId?

[Section titled “constructionId?”](#constructionid)

> `optional` **constructionId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:520](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L520)

Optional stable id for a multi-step construction chain.

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`ConstructionSiteKind`](/declarative-hex-worlds/reference/index/type-aliases/constructionsitekind/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:516](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L516)

Construction state to place. Defaults to `stage-A`.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:518](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L518)

Clockwise 60-degree rotation steps.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:522](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L522)

Uniform render scale.

# CreateGameboardInteractionHandlerPresetOptions

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:216](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L216)

Overrides used when expanding a handler preset into concrete handlers.

## Properties

[Section titled “Properties”](#properties)

### markTargetActorInteracted?

[Section titled “markTargetActorInteracted?”](#marktargetactorinteracted)

> `optional` **markTargetActorInteracted?**: [`MarkTargetActorInteractedHandlerOptions`](/declarative-hex-worlds/reference/index/interfaces/marktargetactorinteractedhandleroptions/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:222](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L222)

Options for `mark-target-interacted`.

***

### removeTargetActor?

[Section titled “removeTargetActor?”](#removetargetactor)

> `optional` **removeTargetActor?**: [`RemoveTargetActorHandlerOptions`](/declarative-hex-worlds/reference/index/interfaces/removetargetactorhandleroptions/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:218](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L218)

Options for `remove-target-actor`.

***

### removeTargetPlacement?

[Section titled “removeTargetPlacement?”](#removetargetplacement)

> `optional` **removeTargetPlacement?**: [`RemoveTargetPlacementHandlerOptions`](/declarative-hex-worlds/reference/index/interfaces/removetargetplacementhandleroptions/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:220](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L220)

Options for `remove-target-placement`.

# CreateGameboardPatrolSimulationScriptOptions

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:678](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L678)

Options for generating a complete simulation script from patrol routes.

## Extends

[Section titled “Extends”](#extends)

* [`CreateGameboardPatrolSimulationStepsOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardpatrolsimulationstepsoptions/)

## Properties

[Section titled “Properties”](#properties)

### assignments

[Section titled “assignments”](#assignments)

> **assignments**: readonly [`GameboardPatrolSimulationActorAssignment`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationactorassignment/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:632](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L632)

Actor-to-route assignments.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`CreateGameboardPatrolSimulationStepsOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardpatrolsimulationstepsoptions/).[`assignments`](/declarative-hex-worlds/reference/index/interfaces/creategameboardpatrolsimulationstepsoptions/#assignments)

***

### defaultCommandHandlerOptions?

[Section titled “defaultCommandHandlerOptions?”](#defaultcommandhandleroptions)

> `optional` **defaultCommandHandlerOptions?**: [`CreateGameboardInteractionHandlerPresetOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardinteractionhandlerpresetoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:687](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L687)

Default handler options for generated script.

***

### defaultCommandHandlers?

[Section titled “defaultCommandHandlers?”](#defaultcommandhandlers)

> `optional` **defaultCommandHandlers?**: readonly (`"remove-target-actor"` | `"remove-target-placement"` | `"mark-target-interacted"` | `"default-rpg"`)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:685](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L685)

Default command handler presets for generated script.

***

### defaultCommandSystems?

[Section titled “defaultCommandSystems?”](#defaultcommandsystems)

> `optional` **defaultCommandSystems?**: `false` | [`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:683](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L683)

Default command systems for generated script.

***

### defaultRunSystems?

[Section titled “defaultRunSystems?”](#defaultrunsystems)

> `optional` **defaultRunSystems?**: [`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:689](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L689)

Default systems for generated run-systems steps.

***

### defaultSourceActor?

[Section titled “defaultSourceActor?”](#defaultsourceactor)

> `optional` **defaultSourceActor?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:681](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L681)

Default source actor id for generated command steps.

***

### expectations?

[Section titled “expectations?”](#expectations)

> `optional` **expectations?**: [`GameboardScenarioSimulationExpectations`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationexpectations/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:691](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L691)

Expectations to embed in the generated script.

***

### requireFoundRoutes?

[Section titled “requireFoundRoutes?”](#requirefoundroutes)

> `optional` **requireFoundRoutes?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:634](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L634)

Whether missing routes should be treated as errors. Defaults to true.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`CreateGameboardPatrolSimulationStepsOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardpatrolsimulationstepsoptions/).[`requireFoundRoutes`](/declarative-hex-worlds/reference/index/interfaces/creategameboardpatrolsimulationstepsoptions/#requirefoundroutes)

***

### routes

[Section titled “routes”](#routes)

> **routes**: `GameboardPatrolRouteSet` | readonly `GameboardPatrolRoutePlan`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:630](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L630)

Patrol route set or route plans.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`CreateGameboardPatrolSimulationStepsOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardpatrolsimulationstepsoptions/).[`routes`](/declarative-hex-worlds/reference/index/interfaces/creategameboardpatrolsimulationstepsoptions/#routes)

# CreateGameboardPatrolSimulationStepsOptions

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:628](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L628)

Options for generating simulation command steps from patrol routes.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`CreateGameboardPatrolSimulationScriptOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardpatrolsimulationscriptoptions/)

## Properties

[Section titled “Properties”](#properties)

### assignments

[Section titled “assignments”](#assignments)

> **assignments**: readonly [`GameboardPatrolSimulationActorAssignment`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationactorassignment/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:632](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L632)

Actor-to-route assignments.

***

### requireFoundRoutes?

[Section titled “requireFoundRoutes?”](#requirefoundroutes)

> `optional` **requireFoundRoutes?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:634](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L634)

Whether missing routes should be treated as errors. Defaults to true.

***

### routes

[Section titled “routes”](#routes)

> **routes**: `GameboardPatrolRouteSet` | readonly `GameboardPatrolRoutePlan`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:630](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L630)

Patrol route set or route plans.

# CreateGameboardRuntimeOptions

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:252](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L252)

Explicit runtime creation options.

## Properties

[Section titled “Properties”](#properties)

### plan?

[Section titled “plan?”](#plan)

> `optional` **plan?**: [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:256](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L256)

Serializable plan to load into a new Koota world.

***

### world?

[Section titled “world?”](#world)

> `optional` **world?**: `World`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:254](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L254)

Existing Koota world to bind.

# CreateGameboardScenarioOptions

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:118](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L118)

Options accepted by the scenario factory.

## Properties

[Section titled “Properties”](#properties)

### actors?

[Section titled “actors?”](#actors)

> `optional` **actors?**: readonly [`GameboardScenarioActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenarioactor/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L126)

Actors to spawn into the scenario runtime.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L130)

Additional serializable scenario metadata.

***

### patrolRoutes?

[Section titled “patrolRoutes?”](#patrolroutes)

> `optional` **patrolRoutes?**: readonly [`GameboardScenarioPatrolRoute`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariopatrolroute/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:124](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L124)

Deterministic patrol route rules for scenario actors.

***

### quests?

[Section titled “quests?”](#quests)

> `optional` **quests?**: readonly [`GameboardQuestDefinition`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestdefinition/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L128)

Quests to spawn into the scenario runtime.

***

### spawnGroups?

[Section titled “spawnGroups?”](#spawngroups)

> `optional` **spawnGroups?**: `GameboardSpawnGroupOptions`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:122](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L122)

Deterministic spawn group rules for scenario actors.

***

### title?

[Section titled “title?”](#title)

> `optional` **title?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:120](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L120)

Optional display title.

# CreateSourceFromSpecOptions

Defined in: [packages/declarative-hex-worlds/src/asset-source/spec-source.ts:28](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/spec-source.ts#L28)

Options for `createSourceFromSpec`.

## Properties

[Section titled “Properties”](#properties)

### tilesetShape?

[Section titled “tilesetShape?”](#tilesetshape)

> `optional` **tilesetShape?**: `"hex"` | `"quad"`

Defined in: [packages/declarative-hex-worlds/src/asset-source/spec-source.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/spec-source.ts#L33)

How each tileset cell is drawn (see `AssetRenderRequest['shape']`). Defaults to the tileset source’s own default (`'quad'`).

# DispatchGameboardActorTargetCommandResult

Defined in: [packages/declarative-hex-worlds/src/systems/command-dispatch.ts:43](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/command-dispatch.ts#L43)

Result of selecting an actor target and dispatching the planned command.

## Properties

[Section titled “Properties”](#properties)

### dispatch?

[Section titled “dispatch?”](#dispatch)

> `optional` **dispatch?**: [`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/command-dispatch.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/command-dispatch.ts#L47)

Dispatch result when the target command was executable.

***

### eventRecords

[Section titled “eventRecords”](#eventrecords)

> **eventRecords**: readonly [`GameboardSystemEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardsystemeventrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/command-dispatch.ts:51](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/command-dispatch.ts#L51)

Serializable event records derived from `events`.

***

### events

[Section titled “events”](#events)

> **events**: readonly [`GameboardSystemEvent`](/declarative-hex-worlds/reference/index/type-aliases/gameboardsystemevent/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/command-dispatch.ts:49](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/command-dispatch.ts#L49)

In-memory events emitted by the dispatch.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/command-dispatch.ts:53](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/command-dispatch.ts#L53)

Reason no command was dispatched or dispatch was blocked.

***

### targetCommand

[Section titled “targetCommand”](#targetcommand)

> **targetCommand**: [`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

Defined in: [packages/declarative-hex-worlds/src/systems/command-dispatch.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/command-dispatch.ts#L45)

Actor-target command plan.

# DispatchGameboardInteractionCommandOptions

Defined in: [packages/declarative-hex-worlds/src/systems/command-dispatch.ts:26](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/command-dispatch.ts#L26)

Command dispatch options used by system helpers.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/)

## Extended by

[Section titled “Extended by”](#extended-by)

* [`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/)

## Properties

[Section titled “Properties”](#properties)

### blockingPlacementKinds?

[Section titled “blockingPlacementKinds?”](#blockingplacementkinds)

> `optional` **blockingPlacementKinds?**: readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L126)

Placement kinds that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/).[`blockingPlacementKinds`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/#blockingplacementkinds)

***

### blockingPlacementLayers?

[Section titled “blockingPlacementLayers?”](#blockingplacementlayers)

> `optional` **blockingPlacementLayers?**: readonly [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L128)

Placement layers that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/).[`blockingPlacementLayers`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/#blockingplacementlayers)

***

### handlers?

[Section titled “handlers?”](#handlers)

> `optional` **handlers?**: [`GameboardInteractionHandler`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandler/) | readonly [`GameboardInteractionHandler`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandler/)\[]

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:240](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L240)

Handler or handler chain for non-movement interact/attack/inspect commands.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/).[`handlers`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/#handlers)

***

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L130)

Placement ids ignored during collision checks.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/).[`ignorePlacementIds`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/#ignoreplacementids)

***

### movement?

[Section titled “movement?”](#movement)

> `optional` **movement?**: [`GameboardMovementPathRequestOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementpathrequestoptions/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:231](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L231)

Movement path options used when the command is a move request.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/).[`movement`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/#movement)

***

### requireSourceActorForAttack?

[Section titled “requireSourceActorForAttack?”](#requiresourceactorforattack)

> `optional` **requireSourceActorForAttack?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:572](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L572)

Require a source actor before attack commands can execute.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/).[`requireSourceActorForAttack`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/#requiresourceactorforattack)

***

### requireSourceActorForInteraction?

[Section titled “requireSourceActorForInteraction?”](#requiresourceactorforinteraction)

> `optional` **requireSourceActorForInteraction?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:574](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L574)

Require a source actor before interaction commands can execute.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/).[`requireSourceActorForInteraction`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/#requiresourceactorforinteraction)

***

### requireSourceActorForMove?

[Section titled “requireSourceActorForMove?”](#requiresourceactorformove)

> `optional` **requireSourceActorForMove?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:570](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L570)

Require a source actor before move commands can execute.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/).[`requireSourceActorForMove`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/#requiresourceactorformove)

***

### sourceActor?

[Section titled “sourceActor?”](#sourceactor)

> `optional` **sourceActor?**: `string` | `Entity`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:216](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L216)

Source actor used for hostility and collision interpretation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/).[`sourceActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/#sourceactor)

***

### treatHostileAsBlocking?

[Section titled “treatHostileAsBlocking?”](#treathostileasblocking)

> `optional` **treatHostileAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:132](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L132)

Treat hostile actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/).[`treatHostileAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/#treathostileasblocking)

***

### treatInteractiveAsBlocking?

[Section titled “treatInteractiveAsBlocking?”](#treatinteractiveasblocking)

> `optional` **treatInteractiveAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L134)

Treat interactive actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/).[`treatInteractiveAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/#treatinteractiveasblocking)

***

### treatPropsAsBlocking?

[Section titled “treatPropsAsBlocking?”](#treatpropsasblocking)

> `optional` **treatPropsAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L136)

Treat prop actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/).[`treatPropsAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/#treatpropsasblocking)

# DispatchGameboardInteractionCommandResult

Defined in: [packages/declarative-hex-worlds/src/systems/command-dispatch.ts:31](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/command-dispatch.ts#L31)

Result of dispatching one interaction command.

## Properties

[Section titled “Properties”](#properties)

### eventRecords

[Section titled “eventRecords”](#eventrecords)

> **eventRecords**: readonly [`GameboardSystemEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardsystemeventrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/command-dispatch.ts:37](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/command-dispatch.ts#L37)

Serializable event records derived from `events`.

***

### events

[Section titled “events”](#events)

> **events**: readonly [`GameboardSystemEvent`](/declarative-hex-worlds/reference/index/type-aliases/gameboardsystemevent/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/command-dispatch.ts:35](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/command-dispatch.ts#L35)

In-memory events emitted by the dispatch.

***

### execution

[Section titled “execution”](#execution)

> **execution**: [`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

Defined in: [packages/declarative-hex-worlds/src/systems/command-dispatch.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/command-dispatch.ts#L33)

Command execution result.

# ElevationRampOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:468](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L468)

Options for adding a sloped grass ramp between adjacent elevation levels.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`AddElevationRampRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addelevationramprecipestep/)

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:470](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L470)

Lower tile where the visible ramp is anchored.

***

### direction?

[Section titled “direction?”](#direction)

> `optional` **direction?**: [`ElevationRampDirection`](/declarative-hex-worlds/reference/index/type-aliases/elevationrampdirection/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:472](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L472)

Visual ramp direction. Defaults to `up`.

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:484](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L484)

Fractional elevation offset above the tile surface.

***

### facing?

[Section titled “facing?”](#facing)

> `optional` **facing?**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:474](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L474)

Edge the ramp points toward; also used as the default rotation.

***

### fromElevation?

[Section titled “fromElevation?”](#fromelevation)

> `optional` **fromElevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:478](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L478)

Elevation on the anchor tile. Defaults to the tile elevation.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:476](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L476)

Clockwise 60-degree rotation steps. Overrides `facing` when provided.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:486](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L486)

Uniform render scale.

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:482](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L482)

Texture set to apply to the anchor tile before placing the ramp.

***

### toElevation?

[Section titled “toElevation?”](#toelevation)

> `optional` **toElevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:480](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L480)

Elevation reached by the ramp. Defaults to one level above or below `fromElevation`.

# FactionBuildingOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:422](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L422)

Options for adding a faction building.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`AddFactionBuildingRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addfactionbuildingrecipestep/)

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:424](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L424)

Tile where the building is anchored.

***

### building

[Section titled “building”](#building)

> **building**: `"archeryrange"` | `"barracks"` | `"blacksmith"` | `"castle"` | `"church"` | `"docks"` | `"home_A"` | `"home_B"` | `"lumbermill"` | `"market"` | `"mine"` | `"shipyard"` | `"shrine"` | `"stables"` | `"tavern"` | `"tent"` | `"townhall"` | `"tower_A"` | `"tower_B"` | `"tower_base"` | `"tower_cannon"` | `"tower_catapult"` | `"watchtower"` | `"watermill"` | `"well"` | `"windmill"` | `"workshop"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:428](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L428)

Faction building kind.

***

### faction

[Section titled “faction”](#faction)

> **faction**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:426](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L426)

Faction color for the building.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:430](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L430)

Clockwise 60-degree rotation steps.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:432](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L432)

Uniform render scale.

# FortificationOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:492](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L492)

Options for adding a wall or fence segment with fortification metadata.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`AddFortificationRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addfortificationrecipestep/)

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:494](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L494)

Tile where the segment is anchored.

***

### enclosureId?

[Section titled “enclosureId?”](#enclosureid)

> `optional` **enclosureId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:504](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L504)

Optional stable id for a multi-segment enclosure.

***

### facing?

[Section titled “facing?”](#facing)

> `optional` **facing?**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:500](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L500)

Edge the segment faces; also used as the default rotation.

***

### material?

[Section titled “material?”](#material)

> `optional` **material?**: [`FortificationMaterial`](/declarative-hex-worlds/reference/index/type-aliases/fortificationmaterial/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:496](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L496)

Material family. Defaults to `wall`.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:502](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L502)

Clockwise 60-degree rotation steps. Overrides `facing` when provided.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:506](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L506)

Uniform render scale.

***

### segment?

[Section titled “segment?”](#segment)

> `optional` **segment?**: [`FortificationSegment`](/declarative-hex-worlds/reference/index/type-aliases/fortificationsegment/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:498](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L498)

Segment visual shape. Defaults to `straight`.

# GameboardActorCollisionProfile

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:124](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L124)

Collision policy used by actor movement, navigation, and targeting helpers.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`GameboardActorNavigationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactornavigationoptions/)
* [`GameboardInteractionTargetOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/)
* [`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/)

## Properties

[Section titled “Properties”](#properties)

### blockingPlacementKinds?

[Section titled “blockingPlacementKinds?”](#blockingplacementkinds)

> `optional` **blockingPlacementKinds?**: readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L126)

Placement kinds that should block actor movement.

***

### blockingPlacementLayers?

[Section titled “blockingPlacementLayers?”](#blockingplacementlayers)

> `optional` **blockingPlacementLayers?**: readonly [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L128)

Placement layers that should block actor movement.

***

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L130)

Placement ids ignored during collision checks.

***

### treatHostileAsBlocking?

[Section titled “treatHostileAsBlocking?”](#treathostileasblocking)

> `optional` **treatHostileAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:132](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L132)

Treat hostile actors as movement blockers.

***

### treatInteractiveAsBlocking?

[Section titled “treatInteractiveAsBlocking?”](#treatinteractiveasblocking)

> `optional` **treatInteractiveAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L134)

Treat interactive actors as movement blockers.

***

### treatPropsAsBlocking?

[Section titled “treatPropsAsBlocking?”](#treatpropsasblocking)

> `optional` **treatPropsAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L136)

Treat prop actors as movement blockers.

# GameboardActorCollisionReport

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:142](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L142)

Collision inspection result for one actor attempting to enter one tile.

## Properties

[Section titled “Properties”](#properties)

### actorPlacements

[Section titled “actorPlacements”](#actorplacements)

> **actorPlacements**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:150](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L150)

Actor placements found on the target tile.

***

### blockingPlacements

[Section titled “blockingPlacements”](#blockingplacements)

> **blockingPlacements**: readonly `object`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:152](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L152)

Placements that block movement under the active collision profile.

***

### canEnter

[Section titled “canEnter”](#canenter)

> **canEnter**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:160](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L160)

Whether the source actor can enter the target tile.

***

### hostileActors

[Section titled “hostileActors”](#hostileactors)

> **hostileActors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:154](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L154)

Hostile actors on the target tile.

***

### interactiveActors

[Section titled “interactiveActors”](#interactiveactors)

> **interactiveActors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:156](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L156)

Interactive actors on the target tile.

***

### placements

[Section titled “placements”](#placements)

> **placements**: readonly `object`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:148](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L148)

Placements found on the target tile after ignored ids are removed.

***

### propActors

[Section titled “propActors”](#propactors)

> **propActors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:158](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L158)

Prop actors on the target tile.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:162](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L162)

Blocked reason when `canEnter` is false.

***

### source?

[Section titled “source?”](#source)

> `optional` **source?**: [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:144](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L144)

Source actor being tested, when provided.

***

### targetTileKey

[Section titled “targetTileKey”](#targettilekey)

> **targetTileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:146](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L146)

Target tile key that was inspected.

# GameboardActorNavigationOptions

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:168](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L168)

Actor-aware navigation options layered on top of a navigation profile.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/)

## Properties

[Section titled “Properties”](#properties)

### baseProfile?

[Section titled “baseProfile?”](#baseprofile)

> `optional` **baseProfile?**: [`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:170](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L170)

Base navigation profile to extend with actor collision behavior.

***

### blockingPlacementKinds?

[Section titled “blockingPlacementKinds?”](#blockingplacementkinds)

> `optional` **blockingPlacementKinds?**: readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L126)

Placement kinds that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`blockingPlacementKinds`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#blockingplacementkinds)

***

### blockingPlacementLayers?

[Section titled “blockingPlacementLayers?”](#blockingplacementlayers)

> `optional` **blockingPlacementLayers?**: readonly [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L128)

Placement layers that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`blockingPlacementLayers`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#blockingplacementlayers)

***

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L130)

Placement ids ignored during collision checks.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`ignorePlacementIds`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#ignoreplacementids)

***

### treatHostileAsBlocking?

[Section titled “treatHostileAsBlocking?”](#treathostileasblocking)

> `optional` **treatHostileAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:132](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L132)

Treat hostile actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`treatHostileAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#treathostileasblocking)

***

### treatInteractiveAsBlocking?

[Section titled “treatInteractiveAsBlocking?”](#treatinteractiveasblocking)

> `optional` **treatInteractiveAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L134)

Treat interactive actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`treatInteractiveAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#treatinteractiveasblocking)

***

### treatPropsAsBlocking?

[Section titled “treatPropsAsBlocking?”](#treatpropsasblocking)

> `optional` **treatPropsAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L136)

Treat prop actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`treatPropsAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#treatpropsasblocking)

# GameboardActorPatrolRouteRecord

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:273](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L273)

Relation payload connecting an actor to a patrol route.

## Properties

[Section titled “Properties”](#properties)

### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:275](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L275)

Actor id.

***

### routeId

[Section titled “routeId”](#routeid)

> **routeId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:277](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L277)

Patrol route id.

# GameboardActorPlacementRecord

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:263](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L263)

Relation payload connecting an actor to its placement.

## Properties

[Section titled “Properties”](#properties)

### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:265](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L265)

Actor id.

***

### placementId

[Section titled “placementId”](#placementid)

> **placementId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:267](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L267)

Placement id.

# GameboardActorRegistrationOptions

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:52](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L52)

Options for attaching gameplay actor state to an existing placement.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/)

## Properties

[Section titled “Properties”](#properties)

### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:54](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L54)

Stable gameplay actor id.

***

### actorKind?

[Section titled “actorKind?”](#actorkind)

> `optional` **actorKind?**: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:56](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L56)

Gameplay actor kind. Defaults from placement kind.

***

### actorMetadata?

[Section titled “actorMetadata?”](#actormetadata)

> `optional` **actorMetadata?**: `Readonly`<`Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:70](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L70)

Serializable actor metadata independent from placement metadata.

***

### blocksMovement?

[Section titled “blocksMovement?”](#blocksmovement)

> `optional` **blocksMovement?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:64](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L64)

Whether this actor blocks actor movement.

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `string` | `null`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L58)

Optional faction identifier.

***

### hostile?

[Section titled “hostile?”](#hostile)

> `optional` **hostile?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:62](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L62)

Whether this actor is generally hostile.

***

### interactive?

[Section titled “interactive?”](#interactive)

> `optional` **interactive?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:66](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L66)

Whether this actor should be considered an interaction target.

***

### tags?

[Section titled “tags?”](#tags)

> `optional` **tags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:68](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L68)

Free-form actor tags used by selectors and quests.

***

### team?

[Section titled “team?”](#team)

> `optional` **team?**: `string` | `null`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:60](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L60)

Optional team identifier. Defaults to faction when omitted.

# GameboardActorSelection

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:418](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L418)

Aggregated actor selection result for gameplay systems and UIs.

## Properties

[Section titled “Properties”](#properties)

### actorIds

[Section titled “actorIds”](#actorids)

> **actorIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:426](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L426)

Matching actor ids.

***

### actors

[Section titled “actors”](#actors)

> **actors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:420](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L420)

Matching actor snapshots.

***

### byTileKey

[Section titled “byTileKey”](#bytilekey)

> **byTileKey**: `Readonly`<`Record`<`string`, readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]>>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:432](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L432)

Matching actors grouped by tile key.

***

### center?

[Section titled “center?”](#center)

> `optional` **center?**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:444](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L444)

Resolved center coordinates used for radius and distance.

***

### centerKey?

[Section titled “centerKey?”](#centerkey)

> `optional` **centerKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:446](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L446)

Resolved center tile key.

***

### count

[Section titled “count”](#count)

> **count**: `number`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:424](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L424)

Number of matching actors.

***

### hostileActors

[Section titled “hostileActors”](#hostileactors)

> **hostileActors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:436](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L436)

Matching actors hostile to the source or generally hostile.

***

### interactiveActors

[Section titled “interactiveActors”](#interactiveactors)

> **interactiveActors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:438](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L438)

Matching interactive actors.

***

### placementIds

[Section titled “placementIds”](#placementids)

> **placementIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:428](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L428)

Matching placement ids.

***

### propActors

[Section titled “propActors”](#propactors)

> **propActors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:440](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L440)

Matching prop actors.

***

### radius?

[Section titled “radius?”](#radius)

> `optional` **radius?**: `number`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:448](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L448)

Normalized radius used for filtering.

***

### records

[Section titled “records”](#records)

> **records**: readonly [`GameboardActorSelectionRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:422](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L422)

Serializable records for matching actors.

***

### recordsByTileKey

[Section titled “recordsByTileKey”](#recordsbytilekey)

> **recordsByTileKey**: `Readonly`<`Record`<`string`, readonly [`GameboardActorSelectionRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionrecord/)\[]>>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:434](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L434)

Matching records grouped by tile key.

***

### source?

[Section titled “source?”](#source)

> `optional` **source?**: [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:442](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L442)

Source actor used for the selection.

***

### tileKeys

[Section titled “tileKeys”](#tilekeys)

> **tileKeys**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:430](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L430)

Unique tile keys occupied by matching actors.

# GameboardActorSelectionOptions

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:378](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L378)

Filter options for selecting actors from the world.

## Properties

[Section titled “Properties”](#properties)

### actorIds?

[Section titled “actorIds?”](#actorids)

> `optional` **actorIds?**: `string` | readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:380](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L380)

Actor id or ids to include.

***

### blocksMovement?

[Section titled “blocksMovement?”](#blocksmovement)

> `optional` **blocksMovement?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:408](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L408)

Filter by actor movement-blocking flag.

***

### center?

[Section titled “center?”](#center)

> `optional` **center?**: [`GameboardNeighborhoodCenter`](/declarative-hex-worlds/reference/index/type-aliases/gameboardneighborhoodcenter/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:396](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L396)

Optional center used by radius filtering and distance sorting.

***

### excludeTags?

[Section titled “excludeTags?”](#excludetags)

> `optional` **excludeTags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:392](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L392)

Actor tags that must all be absent.

***

### factions?

[Section titled “factions?”](#factions)

> `optional` **factions?**: `string` | readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:388](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L388)

Faction id or ids to include.

***

### hostile?

[Section titled “hostile?”](#hostile)

> `optional` **hostile?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:404](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L404)

Filter by actor hostile flag.

***

### hostileToSource?

[Section titled “hostileToSource?”](#hostiletosource)

> `optional` **hostileToSource?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:410](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L410)

Filter by hostility relative to `sourceActor`.

***

### includeSource?

[Section titled “includeSource?”](#includesource)

> `optional` **includeSource?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:402](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L402)

Include the source actor in results. Defaults to true.

***

### interactive?

[Section titled “interactive?”](#interactive)

> `optional` **interactive?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:406](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L406)

Filter by actor interactive flag.

***

### kinds?

[Section titled “kinds?”](#kinds)

> `optional` **kinds?**: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/) | readonly [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:384](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L384)

Actor kind or kinds to include.

***

### placementIds?

[Section titled “placementIds?”](#placementids)

> `optional` **placementIds?**: `string` | readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:382](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L382)

Placement id or ids to include.

***

### radius?

[Section titled “radius?”](#radius)

> `optional` **radius?**: `number`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:398](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L398)

Maximum hex distance from `center` or `sourceActor`.

***

### sort?

[Section titled “sort?”](#sort)

> `optional` **sort?**: [`GameboardActorSelectionSort`](/declarative-hex-worlds/reference/index/type-aliases/gameboardactorselectionsort/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:412](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L412)

Sort mode for selected actors.

***

### sourceActor?

[Section titled “sourceActor?”](#sourceactor)

> `optional` **sourceActor?**: `string` | `Entity`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:400](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L400)

Source actor used for hostility and default center resolution.

***

### tags?

[Section titled “tags?”](#tags)

> `optional` **tags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:390](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L390)

Actor tags that must all be present.

***

### teams?

[Section titled “teams?”](#teams)

> `optional` **teams?**: `string` | readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:386](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L386)

Team id or ids to include.

***

### tileKeys?

[Section titled “tileKeys?”](#tilekeys)

> `optional` **tileKeys?**: `string` | readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:394](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L394)

Tile key or keys to include.

# GameboardActorSelectionRecord

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:454](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L454)

Serializable actor selection row for logs, tests, UIs, and quests.

## Properties

[Section titled “Properties”](#properties)

### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:456](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L456)

Actor id.

***

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:484](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L484)

Placement asset id.

***

### blocksMovement

[Section titled “blocksMovement”](#blocksmovement)

> **blocksMovement**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:470](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L470)

Whether the actor blocks movement.

***

### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:480](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L480)

Occupied tile coordinates.

***

### distance?

[Section titled “distance?”](#distance)

> `optional` **distance?**: `number`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:482](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L482)

Distance from the selection center, when available.

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:462](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L462)

Actor faction id.

***

### hostile

[Section titled “hostile”](#hostile)

> **hostile**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:466](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L466)

Whether the actor is generally hostile.

***

### hostileToSource?

[Section titled “hostileToSource?”](#hostiletosource)

> `optional` **hostileToSource?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:468](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L468)

Whether this actor is hostile to the selection source.

***

### interactive

[Section titled “interactive”](#interactive)

> **interactive**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:472](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L472)

Whether the actor is an interaction target.

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:460](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L460)

Actor kind.

***

### layer

[Section titled “layer”](#layer)

> **layer**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:488](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L488)

Underlying placement layer.

***

### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Readonly`<`Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:476](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L476)

Actor metadata.

***

### placementId

[Section titled “placementId”](#placementid)

> **placementId**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:458](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L458)

Placement id associated with the actor.

***

### placementKind

[Section titled “placementKind”](#placementkind)

> **placementKind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:486](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L486)

Underlying placement kind.

***

### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:490](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L490)

Whether the placement requires local-only EXTRA assets.

***

### tags

[Section titled “tags”](#tags)

> **tags**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:474](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L474)

Actor tags.

***

### team?

[Section titled “team?”](#team)

> `optional` **team?**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:464](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L464)

Actor team id.

***

### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:478](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L478)

Occupied tile key.

# GameboardActorSnapshot

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:112](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L112)

Joined runtime snapshot for an actor entity and its placement.

## Properties

[Section titled “Properties”](#properties)

### actor

[Section titled “actor”](#actor)

> **actor**: `object`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:116](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L116)

Actor trait value.

#### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string` = `''`

Stable gameplay actor id.

#### blocksMovement

[Section titled “blocksMovement”](#blocksmovement)

> **blocksMovement**: `boolean` = `false`

Whether this actor blocks movement.

#### faction

[Section titled “faction”](#faction)

> **faction**: `string` | `undefined`

Optional faction identifier.

#### hostile

[Section titled “hostile”](#hostile)

> **hostile**: `boolean` = `false`

Whether this actor is generally hostile.

#### interactive

[Section titled “interactive”](#interactive)

> **interactive**: `boolean` = `false`

Whether this actor should be treated as an interaction target.

#### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/)

Actor role used by collision, targeting, commands, and fixtures.

#### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>

Serializable actor metadata.

#### tags

[Section titled “tags”](#tags)

> **tags**: `string`\[]

Free-form actor tags.

#### team

[Section titled “team”](#team)

> **team**: `string` | `undefined`

Optional team identifier.

***

### entity

[Section titled “entity”](#entity)

> **entity**: `Entity`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:114](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L114)

Live Koota entity.

***

### placement

[Section titled “placement”](#placement)

> **placement**: `object`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:118](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L118)

Placement trait value associated with the actor.

#### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string` = `''`

Manifest or external registry asset id.

#### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Axial coordinates of the origin tile.

#### elevation

[Section titled “elevation”](#elevation)

> **elevation**: `number` = `0`

Base tile elevation where the placement was spawned.

#### elevationOffset

[Section titled “elevationOffset”](#elevationoffset)

> **elevationOffset**: `number` = `0`

Extra vertical offset above the tile elevation.

#### id

[Section titled “id”](#id)

> **id**: `string` = `''`

Stable placement id.

#### kind

[Section titled “kind”](#kind-1)

> **kind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Gameplay category for rules, selectors, and rendering.

#### layer

[Section titled “layer”](#layer)

> **layer**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Render and occupancy layer.

#### metadata

[Section titled “metadata”](#metadata-1)

> **metadata**: `Record`<`string`, `string` | `number` | `boolean` | `null`>

Serializable placement metadata for rules, ECS interop, and render hints.

#### order

[Section titled “order”](#order)

> **order**: `number` = `0`

Stable sort order used by renderers and snapshots.

#### position

[Section titled “position”](#position)

> **position**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

World-space placement anchor after elevation and local offsets.

#### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean` = `false`

Whether the placement depends on local-only EXTRA assets.

#### rotationRadians

[Section titled “rotationRadians”](#rotationradians)

> **rotationRadians**: `number` = `0`

Rotation in radians derived from `rotationSteps`.

#### rotationSteps

[Section titled “rotationSteps”](#rotationsteps)

> **rotationSteps**: `number` = `0`

Clockwise 60-degree rotation steps.

#### scale

[Section titled “scale”](#scale)

> **scale**: `number` = `1`

Uniform render scale.

#### stackIndex

[Section titled “stackIndex”](#stackindex)

> **stackIndex**: `number` | `undefined`

Optional stack index for layered terrain and vertical props.

#### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

KayKit texture set applied to this placement.

#### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string` = `''`

Origin tile key in `q,r` form.

# GameboardActorTarget

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:524](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L524)

One selected target plus its planned command and path result.

## Properties

[Section titled “Properties”](#properties)

### actor

[Section titled “actor”](#actor)

> **actor**: [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:526](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L526)

Target actor snapshot.

***

### approach

[Section titled “approach”](#approach)

> **approach**: [`GameboardActorTargetApproach`](/declarative-hex-worlds/reference/index/type-aliases/gameboardactortargetapproach/) | `"self"` | `"none"`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:534](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L534)

Approach mode actually used for this target.

***

### approachTileKey?

[Section titled “approachTileKey?”](#approachtilekey)

> `optional` **approachTileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:536](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L536)

Tile key approached by the path.

***

### command

[Section titled “command”](#command)

> **command**: [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:530](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L530)

Planned interaction command for the target.

***

### path

[Section titled “path”](#path)

> **path**: [`GameboardNavigationPathResult`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationpathresult/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:532](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L532)

Path to the selected approach tile.

***

### reachable

[Section titled “reachable”](#reachable)

> **reachable**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:538](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L538)

Whether the target is reachable under the active profile.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:540](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L540)

Unreachable reason.

***

### record

[Section titled “record”](#record)

> **record**: [`GameboardActorSelectionRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionrecord/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:528](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L528)

Serializable target actor record.

# GameboardActorTargetCommandOptions

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:246](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L246)

Options for choosing an actor target and planning a command against it.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardActorTargetingOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/)

## Properties

[Section titled “Properties”](#properties)

### actorIds?

[Section titled “actorIds?”](#actorids)

> `optional` **actorIds?**: `string` | readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:380](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L380)

Actor id or ids to include.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`actorIds`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#actorids)

***

### approach?

[Section titled “approach?”](#approach)

> `optional` **approach?**: [`GameboardActorTargetApproach`](/declarative-hex-worlds/reference/index/type-aliases/gameboardactortargetapproach/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:512](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L512)

Target approach strategy. Defaults to `nearest`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardActorTargetingOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/).[`approach`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/#approach)

***

### blocksMovement?

[Section titled “blocksMovement?”](#blocksmovement)

> `optional` **blocksMovement?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:408](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L408)

Filter by actor movement-blocking flag.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`blocksMovement`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#blocksmovement)

***

### center?

[Section titled “center?”](#center)

> `optional` **center?**: [`GameboardNeighborhoodCenter`](/declarative-hex-worlds/reference/index/type-aliases/gameboardneighborhoodcenter/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:396](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L396)

Optional center used by radius filtering and distance sorting.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`center`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#center)

***

### excludeTags?

[Section titled “excludeTags?”](#excludetags)

> `optional` **excludeTags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:392](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L392)

Actor tags that must all be absent.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`excludeTags`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#excludetags)

***

### factions?

[Section titled “factions?”](#factions)

> `optional` **factions?**: `string` | readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:388](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L388)

Faction id or ids to include.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`factions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#factions)

***

### hostile?

[Section titled “hostile?”](#hostile)

> `optional` **hostile?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:404](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L404)

Filter by actor hostile flag.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`hostile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#hostile)

***

### hostileToSource?

[Section titled “hostileToSource?”](#hostiletosource)

> `optional` **hostileToSource?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:410](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L410)

Filter by hostility relative to `sourceActor`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`hostileToSource`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#hostiletosource)

***

### includeSource?

[Section titled “includeSource?”](#includesource)

> `optional` **includeSource?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:402](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L402)

Include the source actor in results. Defaults to true.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`includeSource`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#includesource)

***

### includeUnreachable?

[Section titled “includeUnreachable?”](#includeunreachable)

> `optional` **includeUnreachable?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:516](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L516)

Include unreachable targets in results. Defaults to true.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`GameboardActorTargetingOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/).[`includeUnreachable`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/#includeunreachable)

***

### interactive?

[Section titled “interactive?”](#interactive)

> `optional` **interactive?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:406](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L406)

Filter by actor interactive flag.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`interactive`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#interactive)

***

### kinds?

[Section titled “kinds?”](#kinds)

> `optional` **kinds?**: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/) | readonly [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:384](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L384)

Actor kind or kinds to include.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`kinds`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#kinds)

***

### maxPathCost?

[Section titled “maxPathCost?”](#maxpathcost)

> `optional` **maxPathCost?**: `number`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:514](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L514)

Maximum accepted path cost.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

[`GameboardActorTargetingOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/).[`maxPathCost`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/#maxpathcost)

***

### navigation?

[Section titled “navigation?”](#navigation)

> `optional` **navigation?**: [`GameboardActorNavigationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactornavigationoptions/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:510](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L510)

Actor-aware navigation options.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`GameboardActorTargetingOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/).[`navigation`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/#navigation)

***

### placementIds?

[Section titled “placementIds?”](#placementids)

> `optional` **placementIds?**: `string` | readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:382](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L382)

Placement id or ids to include.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-14)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`placementIds`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#placementids)

***

### radius?

[Section titled “radius?”](#radius)

> `optional` **radius?**: `number`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:398](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L398)

Maximum hex distance from `center` or `sourceActor`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-15)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`radius`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#radius)

***

### requireReachable?

[Section titled “requireReachable?”](#requirereachable)

> `optional` **requireReachable?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:250](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L250)

Require the selected actor target to be reachable. Defaults to true.

***

### sort?

[Section titled “sort?”](#sort)

> `optional` **sort?**: [`GameboardActorTargetSort`](/declarative-hex-worlds/reference/index/type-aliases/gameboardactortargetsort/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:518](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L518)

Target result sort mode.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-16)

[`GameboardActorTargetingOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/).[`sort`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/#sort)

***

### sourceActor

[Section titled “sourceActor”](#sourceactor)

> **sourceActor**: `string` | `Entity`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:508](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L508)

Source actor that will path toward selected targets.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-17)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/).[`sourceActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/#sourceactor)

***

### tags?

[Section titled “tags?”](#tags)

> `optional` **tags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:390](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L390)

Actor tags that must all be present.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-18)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`tags`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#tags)

***

### targetActorId?

[Section titled “targetActorId?”](#targetactorid)

> `optional` **targetActorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:248](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L248)

Require this exact target actor id instead of using the nearest match.

***

### teams?

[Section titled “teams?”](#teams)

> `optional` **teams?**: `string` | readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:386](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L386)

Team id or ids to include.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-19)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`teams`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#teams)

***

### tileKeys?

[Section titled “tileKeys?”](#tilekeys)

> `optional` **tileKeys?**: `string` | readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:394](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L394)

Tile key or keys to include.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-20)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`tileKeys`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#tilekeys)

# GameboardActorTargetCommandPlan

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:256](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L256)

Non-mutating command plan for a selected actor target.

## Properties

[Section titled “Properties”](#properties)

### canExecute

[Section titled “canExecute”](#canexecute)

> **canExecute**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:264](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L264)

Whether the command may be executed immediately.

***

### command?

[Section titled “command?”](#command)

> `optional` **command?**: [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:262](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L262)

Planned command against the selected target.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:266](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L266)

Reason execution is unavailable.

***

### target?

[Section titled “target?”](#target)

> `optional` **target?**: [`GameboardActorTarget`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortarget/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:260](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L260)

Selected actor target, when one matched.

***

### targeting

[Section titled “targeting”](#targeting)

> **targeting**: [`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:258](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L258)

Full actor-targeting report used to select the target.

# GameboardActorTargetingOptions

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:505](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L505)

Options for selecting and pathing to potential actor targets.

## Extends

[Section titled “Extends”](#extends)

* `Omit`<[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/), `"sourceActor"` | `"sort"`>

## Extended by

[Section titled “Extended by”](#extended-by)

* [`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

## Properties

[Section titled “Properties”](#properties)

### actorIds?

[Section titled “actorIds?”](#actorids)

> `optional` **actorIds?**: `string` | readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:380](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L380)

Actor id or ids to include.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`actorIds`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#actorids)

***

### approach?

[Section titled “approach?”](#approach)

> `optional` **approach?**: [`GameboardActorTargetApproach`](/declarative-hex-worlds/reference/index/type-aliases/gameboardactortargetapproach/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:512](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L512)

Target approach strategy. Defaults to `nearest`.

***

### blocksMovement?

[Section titled “blocksMovement?”](#blocksmovement)

> `optional` **blocksMovement?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:408](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L408)

Filter by actor movement-blocking flag.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`blocksMovement`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#blocksmovement)

***

### center?

[Section titled “center?”](#center)

> `optional` **center?**: [`GameboardNeighborhoodCenter`](/declarative-hex-worlds/reference/index/type-aliases/gameboardneighborhoodcenter/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:396](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L396)

Optional center used by radius filtering and distance sorting.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`center`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#center)

***

### excludeTags?

[Section titled “excludeTags?”](#excludetags)

> `optional` **excludeTags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:392](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L392)

Actor tags that must all be absent.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`excludeTags`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#excludetags)

***

### factions?

[Section titled “factions?”](#factions)

> `optional` **factions?**: `string` | readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:388](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L388)

Faction id or ids to include.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`factions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#factions)

***

### hostile?

[Section titled “hostile?”](#hostile)

> `optional` **hostile?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:404](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L404)

Filter by actor hostile flag.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`hostile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#hostile)

***

### hostileToSource?

[Section titled “hostileToSource?”](#hostiletosource)

> `optional` **hostileToSource?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:410](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L410)

Filter by hostility relative to `sourceActor`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`hostileToSource`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#hostiletosource)

***

### includeSource?

[Section titled “includeSource?”](#includesource)

> `optional` **includeSource?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:402](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L402)

Include the source actor in results. Defaults to true.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`includeSource`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#includesource)

***

### includeUnreachable?

[Section titled “includeUnreachable?”](#includeunreachable)

> `optional` **includeUnreachable?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:516](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L516)

Include unreachable targets in results. Defaults to true.

***

### interactive?

[Section titled “interactive?”](#interactive)

> `optional` **interactive?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:406](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L406)

Filter by actor interactive flag.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`interactive`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#interactive)

***

### kinds?

[Section titled “kinds?”](#kinds)

> `optional` **kinds?**: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/) | readonly [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:384](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L384)

Actor kind or kinds to include.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`kinds`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#kinds)

***

### maxPathCost?

[Section titled “maxPathCost?”](#maxpathcost)

> `optional` **maxPathCost?**: `number`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:514](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L514)

Maximum accepted path cost.

***

### navigation?

[Section titled “navigation?”](#navigation)

> `optional` **navigation?**: [`GameboardActorNavigationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactornavigationoptions/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:510](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L510)

Actor-aware navigation options.

***

### placementIds?

[Section titled “placementIds?”](#placementids)

> `optional` **placementIds?**: `string` | readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:382](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L382)

Placement id or ids to include.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`placementIds`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#placementids)

***

### radius?

[Section titled “radius?”](#radius)

> `optional` **radius?**: `number`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:398](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L398)

Maximum hex distance from `center` or `sourceActor`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`radius`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#radius)

***

### sort?

[Section titled “sort?”](#sort)

> `optional` **sort?**: [`GameboardActorTargetSort`](/declarative-hex-worlds/reference/index/type-aliases/gameboardactortargetsort/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:518](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L518)

Target result sort mode.

***

### sourceActor

[Section titled “sourceActor”](#sourceactor)

> **sourceActor**: `string` | `Entity`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:508](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L508)

Source actor that will path toward selected targets.

***

### tags?

[Section titled “tags?”](#tags)

> `optional` **tags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:390](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L390)

Actor tags that must all be present.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`tags`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#tags)

***

### teams?

[Section titled “teams?”](#teams)

> `optional` **teams?**: `string` | readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:386](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L386)

Team id or ids to include.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`teams`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#teams)

***

### tileKeys?

[Section titled “tileKeys?”](#tilekeys)

> `optional` **tileKeys?**: `string` | readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:394](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L394)

Tile key or keys to include.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-14)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/).[`tileKeys`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/#tilekeys)

# GameboardActorTargetingReport

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:546](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L546)

Targeting report for one source actor.

## Properties

[Section titled “Properties”](#properties)

### nearestTarget?

[Section titled “nearestTarget?”](#nearesttarget)

> `optional` **nearestTarget?**: [`GameboardActorTarget`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortarget/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:560](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L560)

First reachable target, or first target when none are reachable.

***

### reachableActorIds

[Section titled “reachableActorIds”](#reachableactorids)

> **reachableActorIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:558](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L558)

Actor ids represented by `reachableTargets`.

***

### reachableTargets

[Section titled “reachableTargets”](#reachabletargets)

> **reachableTargets**: readonly [`GameboardActorTarget`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortarget/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:554](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L554)

Reachable targets only.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:562](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L562)

Failure reason when targeting could not be evaluated.

***

### selection

[Section titled “selection”](#selection)

> **selection**: [`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:550](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L550)

Actor selection used as the target candidate set.

***

### source?

[Section titled “source?”](#source)

> `optional` **source?**: [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:548](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L548)

Source actor, when it exists.

***

### targetActorIds

[Section titled “targetActorIds”](#targetactorids)

> **targetActorIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:556](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L556)

Actor ids represented by `targets`.

***

### targets

[Section titled “targets”](#targets)

> **targets**: readonly [`GameboardActorTarget`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortarget/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:552](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L552)

All targets after reachability filtering.

# GameboardActorTileRecord

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:251](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L251)

Relation payload connecting an actor to a tile.

## Properties

[Section titled “Properties”](#properties)

### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:253](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L253)

Actor id.

***

### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:257](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L257)

Tile coordinates occupied by the actor.

***

### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:255](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L255)

Tile key occupied by the actor.

# GameboardAdjacencyRecord

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:94](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L94)

Directional adjacency relation between two tiles.

## Properties

[Section titled “Properties”](#properties)

### edge

[Section titled “edge”](#edge)

> **edge**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:100](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L100)

Source edge leading to the target tile.

***

### from

[Section titled “from”](#from)

> **from**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:96](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L96)

Source tile key.

***

### reciprocalEdge

[Section titled “reciprocalEdge”](#reciprocaledge)

> **reciprocalEdge**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:102](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L102)

Target edge leading back to the source tile.

***

### to

[Section titled “to”](#to)

> **to**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:98](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L98)

Target tile key.

# GameboardCommandBlockedEvent

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L67)

Command execution was blocked before mutation.

## Properties

[Section titled “Properties”](#properties)

### execution

[Section titled “execution”](#execution)

> **execution**: [`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:71](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L71)

Command execution that failed.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:73](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L73)

Blocked reason.

***

### type

[Section titled “type”](#type)

> **type**: `"command-blocked"`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:69](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L69)

Event discriminator.

# GameboardCommandHandledEvent

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:57](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L57)

Command execution completed through a handler.

## Properties

[Section titled “Properties”](#properties)

### execution

[Section titled “execution”](#execution)

> **execution**: [`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:61](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L61)

Command execution that was handled.

***

### type

[Section titled “type”](#type)

> **type**: `"command-handled"`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:59](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L59)

Event discriminator.

# GameboardCommandHandlerRequiredEvent

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:91](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L91)

Command requires a host-game handler before it can mutate state.

## Properties

[Section titled “Properties”](#properties)

### execution

[Section titled “execution”](#execution)

> **execution**: [`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:95](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L95)

Command execution awaiting a handler.

***

### type

[Section titled “type”](#type)

> **type**: `"command-handler-required"`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:93](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L93)

Event discriminator.

# GameboardCommandIgnoredEvent

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:79](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L79)

Command execution had no effect.

## Properties

[Section titled “Properties”](#properties)

### execution

[Section titled “execution”](#execution)

> **execution**: [`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:83](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L83)

Command execution that was ignored.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:85](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L85)

Ignored reason.

***

### type

[Section titled “type”](#type)

> **type**: `"command-ignored"`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:81](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L81)

Event discriminator.

# GameboardEcsAdapter

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:573](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L573)

Adapter interface for mounting a gameboard snapshot into another ECS.

## Type Parameters

[Section titled “Type Parameters”](#type-parameters)

### TEntity

[Section titled “TEntity”](#tentity)

`TEntity`

## Properties

[Section titled “Properties”](#properties)

### addComponent?

[Section titled “addComponent?”](#addcomponent)

> `optional` **addComponent?**: (`entity`, `componentName`, `componentValue`, `source`) => `void`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:577](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L577)

Add a component to a host ECS entity.

#### Parameters

[Section titled “Parameters”](#parameters)

##### entity

[Section titled “entity”](#entity)

`TEntity`

##### componentName

[Section titled “componentName”](#componentname)

`string`

##### componentValue

[Section titled “componentValue”](#componentvalue)

`unknown`

##### source

[Section titled “source”](#source)

[`GameboardInteropEntity`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropentity/)

#### Returns

[Section titled “Returns”](#returns)

`void`

***

### addRelation?

[Section titled “addRelation?”](#addrelation)

> `optional` **addRelation?**: (`from`, `to`, `relation`) => `void`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:584](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L584)

Add a relation between two host ECS entities.

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### from

[Section titled “from”](#from)

`TEntity`

##### to

[Section titled “to”](#to)

`TEntity`

##### relation

[Section titled “relation”](#relation)

[`GameboardEcsRelation`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsrelation/)

#### Returns

[Section titled “Returns”](#returns-1)

`void`

***

### createEntity

[Section titled “createEntity”](#createentity)

> **createEntity**: (`entity`) => `TEntity`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:575](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L575)

Create a host ECS entity from an interop entity.

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### entity

[Section titled “entity”](#entity-1)

[`GameboardInteropEntity`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropentity/)

#### Returns

[Section titled “Returns”](#returns-2)

`TEntity`

# GameboardEcsMountResult

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:590](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L590)

Result of mounting an interop snapshot into an ECS adapter.

## Type Parameters

[Section titled “Type Parameters”](#type-parameters)

### TEntity

[Section titled “TEntity”](#tentity)

`TEntity`

## Properties

[Section titled “Properties”](#properties)

### entitiesById

[Section titled “entitiesById”](#entitiesbyid)

> **entitiesById**: `ReadonlyMap`<`string`, `TEntity`>

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:592](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L592)

Mounted host entities keyed by interop entity id.

***

### missingRelations

[Section titled “missingRelations”](#missingrelations)

> **missingRelations**: readonly [`GameboardEcsRelation`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsrelation/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:594](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L594)

Relations whose source or target entities were missing.

# GameboardEcsRelation

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:545](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L545)

Portable relation between two interop entities.

## Properties

[Section titled “Properties”](#properties)

### data

[Section titled “data”](#data)

> **data**: [`GameboardAdjacencyRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardadjacencyrecord/) | [`GameboardPlacementTileRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementtilerecord/) | [`GameboardPlacementOccupancyRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyrecord/) | [`GameboardSpawnTileRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardspawntilerecord/) | [`GameboardSpawnGroupLocationRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardspawngrouplocationrecord/) | [`GameboardSpawnGroupRouteRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardspawngrouprouterecord/) | [`GameboardPatrolWaypointRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolwaypointrecord/) | [`GameboardPatrolRouteSegmentRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolroutesegmentrecord/) | [`GameboardActorTileRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortilerecord/) | [`GameboardActorPlacementRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorplacementrecord/) | [`GameboardActorPatrolRouteRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorpatrolrouterecord/) | [`GameboardQuestActorReferenceRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestactorreferencerecord/) | [`GameboardQuestTileReferenceRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardquesttilereferencerecord/) | [`GameboardSimulationRelationRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardsimulationrelationrecord/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:553](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L553)

Relation payload.

***

### fromId

[Section titled “fromId”](#fromid)

> **fromId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:549](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L549)

Source entity id.

***

### name

[Section titled “name”](#name)

> **name**: [`GameboardEcsRelationName`](/declarative-hex-worlds/reference/index/type-aliases/gameboardecsrelationname/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:547](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L547)

Relation name.

***

### toId

[Section titled “toId”](#toid)

> **toId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:551](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L551)

Target entity id.

# GameboardEntityIndex

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:262](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L262)

Entity indexes returned after loading a complete board plan.

## Properties

[Section titled “Properties”](#properties)

### placements

[Section titled “placements”](#placements)

> **placements**: `Map`<`string`, `Entity`>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:266](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L266)

Placement entities keyed by placement id.

***

### tiles

[Section titled “tiles”](#tiles)

> **tiles**: `Map`<`string`, `Entity`>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:264](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L264)

Tile entities keyed by axial tile key.

# GameboardInteractionCommand

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:580](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L580)

Planned high-level interaction command.

## Properties

[Section titled “Properties”](#properties)

### actorId?

[Section titled “actorId?”](#actorid)

> `optional` **actorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:594](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L594)

Target actor id, when available.

***

### canExecute

[Section titled “canExecute”](#canexecute)

> **canExecute**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:596](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L596)

Whether this command can execute without additional target resolution.

***

### intent

[Section titled “intent”](#intent)

> **intent**: [`GameboardInteractionIntent`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionintent/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:584](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L584)

High-level intent that produced the command.

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardInteractionCommandKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandkind/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:582](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L582)

Concrete command kind.

***

### placementId?

[Section titled “placementId?”](#placementid)

> `optional` **placementId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:592](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L592)

Target placement id, when available.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:598](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L598)

Failure reason when `canExecute` is false.

***

### source?

[Section titled “source?”](#source)

> `optional` **source?**: [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:588](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L588)

Optional source actor.

***

### target

[Section titled “target”](#target)

> **target**: [`GameboardInteractionTargetReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetreport/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:586](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L586)

Target report used to plan the command.

***

### tileKey?

[Section titled “tileKey?”](#tilekey)

> `optional` **tileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:590](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L590)

Target tile key, when available.

# GameboardInteractionCommandExecution

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:288](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L288)

Result of executing a command preview.

## Properties

[Section titled “Properties”](#properties)

### command

[Section titled “command”](#command)

> **command**: [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:290](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L290)

Planned command that was executed or rejected.

***

### effects?

[Section titled “effects?”](#effects)

> `optional` **effects?**: readonly [`GameboardInteractionHandlerEffect`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandlereffect/)\[]

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:300](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L300)

Flattened handler side effects.

***

### handler?

[Section titled “handler?”](#handler)

> `optional` **handler?**: [`GameboardInteractionHandlerResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractionhandlerresult/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:298](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L298)

Handler result for handler-backed commands.

***

### movement?

[Section titled “movement?”](#movement)

> `optional` **movement?**: [`GameboardMovementRequestResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementrequestresult/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:296](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L296)

Movement request created for move commands.

***

### preview

[Section titled “preview”](#preview)

> **preview**: [`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:292](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L292)

Preview result used for execution.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:302](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L302)

Reason execution was blocked, ignored, or handler-dependent.

***

### status

[Section titled “status”](#status)

> **status**: [`GameboardInteractionExecutionStatus`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionexecutionstatus/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:294](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L294)

Final execution status.

# GameboardInteractionCommandExecutionOptions

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:237](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L237)

Options for executing a command preview and optionally invoking game handlers.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/)

## Extended by

[Section titled “Extended by”](#extended-by)

* [`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/)

## Properties

[Section titled “Properties”](#properties)

### blockingPlacementKinds?

[Section titled “blockingPlacementKinds?”](#blockingplacementkinds)

> `optional` **blockingPlacementKinds?**: readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L126)

Placement kinds that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/).[`blockingPlacementKinds`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/#blockingplacementkinds)

***

### blockingPlacementLayers?

[Section titled “blockingPlacementLayers?”](#blockingplacementlayers)

> `optional` **blockingPlacementLayers?**: readonly [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L128)

Placement layers that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/).[`blockingPlacementLayers`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/#blockingplacementlayers)

***

### handlers?

[Section titled “handlers?”](#handlers)

> `optional` **handlers?**: [`GameboardInteractionHandler`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandler/) | readonly [`GameboardInteractionHandler`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandler/)\[]

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:240](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L240)

Handler or handler chain for non-movement interact/attack/inspect commands.

***

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L130)

Placement ids ignored during collision checks.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/).[`ignorePlacementIds`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/#ignoreplacementids)

***

### movement?

[Section titled “movement?”](#movement)

> `optional` **movement?**: [`GameboardMovementPathRequestOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementpathrequestoptions/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:231](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L231)

Movement path options used when the command is a move request.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/).[`movement`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/#movement)

***

### requireSourceActorForAttack?

[Section titled “requireSourceActorForAttack?”](#requiresourceactorforattack)

> `optional` **requireSourceActorForAttack?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:572](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L572)

Require a source actor before attack commands can execute.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/).[`requireSourceActorForAttack`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/#requiresourceactorforattack)

***

### requireSourceActorForInteraction?

[Section titled “requireSourceActorForInteraction?”](#requiresourceactorforinteraction)

> `optional` **requireSourceActorForInteraction?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:574](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L574)

Require a source actor before interaction commands can execute.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/).[`requireSourceActorForInteraction`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/#requiresourceactorforinteraction)

***

### requireSourceActorForMove?

[Section titled “requireSourceActorForMove?”](#requiresourceactorformove)

> `optional` **requireSourceActorForMove?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:570](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L570)

Require a source actor before move commands can execute.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/).[`requireSourceActorForMove`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/#requiresourceactorformove)

***

### sourceActor?

[Section titled “sourceActor?”](#sourceactor)

> `optional` **sourceActor?**: `string` | `Entity`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:216](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L216)

Source actor used for hostility and collision interpretation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/).[`sourceActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/#sourceactor)

***

### treatHostileAsBlocking?

[Section titled “treatHostileAsBlocking?”](#treathostileasblocking)

> `optional` **treatHostileAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:132](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L132)

Treat hostile actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/).[`treatHostileAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/#treathostileasblocking)

***

### treatInteractiveAsBlocking?

[Section titled “treatInteractiveAsBlocking?”](#treatinteractiveasblocking)

> `optional` **treatInteractiveAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L134)

Treat interactive actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/).[`treatInteractiveAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/#treatinteractiveasblocking)

***

### treatPropsAsBlocking?

[Section titled “treatPropsAsBlocking?”](#treatpropsasblocking)

> `optional` **treatPropsAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L136)

Treat prop actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/).[`treatPropsAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/#treatpropsasblocking)

# GameboardInteractionCommandOptions

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:568](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L568)

Options for planning an interaction command from a resolved target.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardInteractionTargetOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/)

## Extended by

[Section titled “Extended by”](#extended-by)

* [`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/)

## Properties

[Section titled “Properties”](#properties)

### blockingPlacementKinds?

[Section titled “blockingPlacementKinds?”](#blockingplacementkinds)

> `optional` **blockingPlacementKinds?**: readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L126)

Placement kinds that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardInteractionTargetOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/).[`blockingPlacementKinds`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/#blockingplacementkinds)

***

### blockingPlacementLayers?

[Section titled “blockingPlacementLayers?”](#blockingplacementlayers)

> `optional` **blockingPlacementLayers?**: readonly [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L128)

Placement layers that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardInteractionTargetOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/).[`blockingPlacementLayers`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/#blockingplacementlayers)

***

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L130)

Placement ids ignored during collision checks.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardInteractionTargetOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/).[`ignorePlacementIds`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/#ignoreplacementids)

***

### requireSourceActorForAttack?

[Section titled “requireSourceActorForAttack?”](#requiresourceactorforattack)

> `optional` **requireSourceActorForAttack?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:572](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L572)

Require a source actor before attack commands can execute.

***

### requireSourceActorForInteraction?

[Section titled “requireSourceActorForInteraction?”](#requiresourceactorforinteraction)

> `optional` **requireSourceActorForInteraction?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:574](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L574)

Require a source actor before interaction commands can execute.

***

### requireSourceActorForMove?

[Section titled “requireSourceActorForMove?”](#requiresourceactorformove)

> `optional` **requireSourceActorForMove?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:570](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L570)

Require a source actor before move commands can execute.

***

### sourceActor?

[Section titled “sourceActor?”](#sourceactor)

> `optional` **sourceActor?**: `string` | `Entity`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:216](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L216)

Source actor used for hostility and collision interpretation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardInteractionTargetOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/).[`sourceActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/#sourceactor)

***

### treatHostileAsBlocking?

[Section titled “treatHostileAsBlocking?”](#treathostileasblocking)

> `optional` **treatHostileAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:132](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L132)

Treat hostile actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardInteractionTargetOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/).[`treatHostileAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/#treathostileasblocking)

***

### treatInteractiveAsBlocking?

[Section titled “treatInteractiveAsBlocking?”](#treatinteractiveasblocking)

> `optional` **treatInteractiveAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L134)

Treat interactive actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardInteractionTargetOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/).[`treatInteractiveAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/#treatinteractiveasblocking)

***

### treatPropsAsBlocking?

[Section titled “treatPropsAsBlocking?”](#treatpropsasblocking)

> `optional` **treatPropsAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L136)

Treat prop actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardInteractionTargetOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/).[`treatPropsAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/#treatpropsasblocking)

# GameboardInteractionCommandPreview

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:272](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L272)

Non-mutating execution preview for one interaction command.

## Properties

[Section titled “Properties”](#properties)

### canExecute

[Section titled “canExecute”](#canexecute)

> **canExecute**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:280](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L280)

Whether the command can execute under current rules.

***

### command

[Section titled “command”](#command)

> **command**: [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:274](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L274)

Planned command being previewed.

***

### movementBudget?

[Section titled “movementBudget?”](#movementbudget)

> `optional` **movementBudget?**: `number`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:278](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L278)

Movement budget used for range checks.

***

### movementPath?

[Section titled “movementPath?”](#movementpath)

> `optional` **movementPath?**: [`GameboardNavigationPathResult`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationpathresult/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:276](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L276)

Movement path when the command requests movement.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:282](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L282)

Reason execution is unavailable.

# GameboardInteractionCommandPreviewOptions

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:228](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L228)

Options for previewing an interaction command without mutating the world.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/)

## Extended by

[Section titled “Extended by”](#extended-by)

* [`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/)

## Properties

[Section titled “Properties”](#properties)

### blockingPlacementKinds?

[Section titled “blockingPlacementKinds?”](#blockingplacementkinds)

> `optional` **blockingPlacementKinds?**: readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L126)

Placement kinds that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/).[`blockingPlacementKinds`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/#blockingplacementkinds)

***

### blockingPlacementLayers?

[Section titled “blockingPlacementLayers?”](#blockingplacementlayers)

> `optional` **blockingPlacementLayers?**: readonly [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L128)

Placement layers that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/).[`blockingPlacementLayers`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/#blockingplacementlayers)

***

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L130)

Placement ids ignored during collision checks.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/).[`ignorePlacementIds`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/#ignoreplacementids)

***

### movement?

[Section titled “movement?”](#movement)

> `optional` **movement?**: [`GameboardMovementPathRequestOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementpathrequestoptions/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:231](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L231)

Movement path options used when the command is a move request.

***

### requireSourceActorForAttack?

[Section titled “requireSourceActorForAttack?”](#requiresourceactorforattack)

> `optional` **requireSourceActorForAttack?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:572](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L572)

Require a source actor before attack commands can execute.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/).[`requireSourceActorForAttack`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/#requiresourceactorforattack)

***

### requireSourceActorForInteraction?

[Section titled “requireSourceActorForInteraction?”](#requiresourceactorforinteraction)

> `optional` **requireSourceActorForInteraction?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:574](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L574)

Require a source actor before interaction commands can execute.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/).[`requireSourceActorForInteraction`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/#requiresourceactorforinteraction)

***

### requireSourceActorForMove?

[Section titled “requireSourceActorForMove?”](#requiresourceactorformove)

> `optional` **requireSourceActorForMove?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:570](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L570)

Require a source actor before move commands can execute.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/).[`requireSourceActorForMove`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/#requiresourceactorformove)

***

### sourceActor?

[Section titled “sourceActor?”](#sourceactor)

> `optional` **sourceActor?**: `string` | `Entity`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:216](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L216)

Source actor used for hostility and collision interpretation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/).[`sourceActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/#sourceactor)

***

### treatHostileAsBlocking?

[Section titled “treatHostileAsBlocking?”](#treathostileasblocking)

> `optional` **treatHostileAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:132](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L132)

Treat hostile actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/).[`treatHostileAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/#treathostileasblocking)

***

### treatInteractiveAsBlocking?

[Section titled “treatInteractiveAsBlocking?”](#treatinteractiveasblocking)

> `optional` **treatInteractiveAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L134)

Treat interactive actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/).[`treatInteractiveAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/#treatinteractiveasblocking)

***

### treatPropsAsBlocking?

[Section titled “treatPropsAsBlocking?”](#treatpropsasblocking)

> `optional` **treatPropsAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L136)

Treat prop actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/).[`treatPropsAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/#treatpropsasblocking)

# GameboardInteractionCommandRecord

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:233](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L233)

Serializable command execution record.

## Properties

[Section titled “Properties”](#properties)

### actorId?

[Section titled “actorId?”](#actorid)

> `optional` **actorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:259](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L259)

Target actor id, when applicable.

***

### canExecute

[Section titled “canExecute”](#canexecute)

> **canExecute**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:241](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L241)

Whether the command could execute at dispatch time.

***

### effects?

[Section titled “effects?”](#effects)

> `optional` **effects?**: readonly [`GameboardInteractionHandlerEffect`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandlereffect/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:253](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L253)

Full handler side effects.

***

### effectTypes?

[Section titled “effectTypes?”](#effecttypes)

> `optional` **effectTypes?**: readonly (`"actor-removed"` | `"placement-removed"` | `"actor-updated"` | `"placement-updated"`)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:251](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L251)

Side-effect type list for compact reporting.

***

### handlerId?

[Section titled “handlerId?”](#handlerid)

> `optional` **handlerId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:245](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L245)

Handler id when a handler processed the command.

***

### handlerMetadata?

[Section titled “handlerMetadata?”](#handlermetadata)

> `optional` **handlerMetadata?**: `Readonly`<`Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>>

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:249](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L249)

Handler metadata when supplied.

***

### handlerStatus?

[Section titled “handlerStatus?”](#handlerstatus)

> `optional` **handlerStatus?**: [`GameboardInteractionHandlerStatus`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandlerstatus/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:247](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L247)

Handler status when a handler processed the command.

***

### intent

[Section titled “intent”](#intent)

> **intent**: [`GameboardInteractionIntent`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionintent/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:237](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L237)

Command intent.

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardInteractionCommandKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandkind/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:235](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L235)

Command kind.

***

### placementId?

[Section titled “placementId?”](#placementid)

> `optional` **placementId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:257](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L257)

Target placement id, when applicable.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:243](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L243)

Optional blocked or handler reason.

***

### sourceActorId?

[Section titled “sourceActorId?”](#sourceactorid)

> `optional` **sourceActorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:261](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L261)

Source actor id, when applicable.

***

### sourcePlacementId?

[Section titled “sourcePlacementId?”](#sourceplacementid)

> `optional` **sourcePlacementId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:263](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L263)

Source placement id, when applicable.

***

### status

[Section titled “status”](#status)

> **status**: [`GameboardInteractionExecutionStatus`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionexecutionstatus/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:239](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L239)

Execution status.

***

### target

[Section titled “target”](#target)

> **target**: `object`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:265](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L265)

Resolved target summary.

#### actorId?

[Section titled “actorId?”](#actorid-1)

> `optional` **actorId?**: `string`

Target actor id.

#### canEnter

[Section titled “canEnter”](#canenter)

> **canEnter**: `boolean`

Whether the source can enter the target tile.

#### intent

[Section titled “intent”](#intent-1)

> **intent**: [`GameboardInteractionIntent`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionintent/)

Target intent.

#### kind

[Section titled “kind”](#kind-1)

> **kind**: [`GameboardInteractionTargetKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetkind/)

Target kind.

#### placementId?

[Section titled “placementId?”](#placementid-1)

> `optional` **placementId?**: `string`

Target placement id.

#### tileKey?

[Section titled “tileKey?”](#tilekey)

> `optional` **tileKey?**: `string`

Target tile key.

***

### tileKey?

[Section titled “tileKey?”](#tilekey-1)

> `optional` **tileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:255](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L255)

Target tile key, when applicable.

# GameboardInteractionHandlerContext

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:141](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L141)

Context passed to a game-supplied command handler.

## Properties

[Section titled “Properties”](#properties)

### command

[Section titled “command”](#command)

> **command**: [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:145](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L145)

Planned command being handled.

***

### preview

[Section titled “preview”](#preview)

> **preview**: [`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:147](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L147)

Non-mutating execution preview used to reach this handler.

***

### world

[Section titled “world”](#world)

> **world**: `World`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:143](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L143)

Live Koota world being mutated by the command.

# GameboardInteractionHandlerResult

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:118](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L118)

Result returned by a game-supplied interaction handler.

## Properties

[Section titled “Properties”](#properties)

### effects?

[Section titled “effects?”](#effects)

> `optional` **effects?**: readonly [`GameboardInteractionHandlerEffect`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandlereffect/)\[]

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L126)

Serializable side effects produced by the handler.

***

### handlerId?

[Section titled “handlerId?”](#handlerid)

> `optional` **handlerId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:120](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L120)

Stable handler id used by event records and simulation reports.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>>

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L128)

Serializable metadata copied into command event records.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:124](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L124)

Optional failure or blocked reason.

***

### status

[Section titled “status”](#status)

> **status**: [`GameboardInteractionHandlerStatus`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandlerstatus/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:122](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L122)

Handler outcome.

# GameboardInteractionTargetOptions

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:214](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L214)

Options for inspecting an interaction target.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/)

## Extended by

[Section titled “Extended by”](#extended-by)

* [`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/)

## Properties

[Section titled “Properties”](#properties)

### blockingPlacementKinds?

[Section titled “blockingPlacementKinds?”](#blockingplacementkinds)

> `optional` **blockingPlacementKinds?**: readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L126)

Placement kinds that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`blockingPlacementKinds`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#blockingplacementkinds)

***

### blockingPlacementLayers?

[Section titled “blockingPlacementLayers?”](#blockingplacementlayers)

> `optional` **blockingPlacementLayers?**: readonly [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L128)

Placement layers that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`blockingPlacementLayers`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#blockingplacementlayers)

***

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L130)

Placement ids ignored during collision checks.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`ignorePlacementIds`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#ignoreplacementids)

***

### sourceActor?

[Section titled “sourceActor?”](#sourceactor)

> `optional` **sourceActor?**: `string` | `Entity`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:216](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L216)

Source actor used for hostility and collision interpretation.

***

### treatHostileAsBlocking?

[Section titled “treatHostileAsBlocking?”](#treathostileasblocking)

> `optional` **treatHostileAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:132](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L132)

Treat hostile actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`treatHostileAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#treathostileasblocking)

***

### treatInteractiveAsBlocking?

[Section titled “treatInteractiveAsBlocking?”](#treatinteractiveasblocking)

> `optional` **treatInteractiveAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L134)

Treat interactive actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`treatInteractiveAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#treatinteractiveasblocking)

***

### treatPropsAsBlocking?

[Section titled “treatPropsAsBlocking?”](#treatpropsasblocking)

> `optional` **treatPropsAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L136)

Treat prop actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`treatPropsAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#treatpropsasblocking)

# GameboardInteractionTargetReport

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:222](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L222)

Resolved interaction target plus nearby placement, actor, and collision data.

## Properties

[Section titled “Properties”](#properties)

### actor?

[Section titled “actor?”](#actor)

> `optional` **actor?**: [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:232](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L232)

Resolved actor target.

***

### actors

[Section titled “actors”](#actors)

> **actors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:236](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L236)

Actors on the resolved tile.

***

### canEnter

[Section titled “canEnter”](#canenter)

> **canEnter**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:240](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L240)

Whether the source actor can enter the resolved tile.

***

### collision?

[Section titled “collision?”](#collision)

> `optional` **collision?**: [`GameboardActorCollisionReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionreport/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:238](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L238)

Actor collision report for the resolved tile.

***

### intent

[Section titled “intent”](#intent)

> **intent**: [`GameboardInteractionIntent`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionintent/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:226](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L226)

Inferred interaction intent.

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardInteractionTargetKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetkind/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:224](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L224)

Resolved target kind.

***

### placement?

[Section titled “placement?”](#placement)

> `optional` **placement?**: `object`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:230](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L230)

Resolved placement target.

#### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string` = `''`

Manifest or external registry asset id.

#### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Axial coordinates of the origin tile.

#### elevation

[Section titled “elevation”](#elevation)

> **elevation**: `number` = `0`

Base tile elevation where the placement was spawned.

#### elevationOffset

[Section titled “elevationOffset”](#elevationoffset)

> **elevationOffset**: `number` = `0`

Extra vertical offset above the tile elevation.

#### id

[Section titled “id”](#id)

> **id**: `string` = `''`

Stable placement id.

#### kind

[Section titled “kind”](#kind-1)

> **kind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Gameplay category for rules, selectors, and rendering.

#### layer

[Section titled “layer”](#layer)

> **layer**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Render and occupancy layer.

#### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Record`<`string`, `string` | `number` | `boolean` | `null`>

Serializable placement metadata for rules, ECS interop, and render hints.

#### order

[Section titled “order”](#order)

> **order**: `number` = `0`

Stable sort order used by renderers and snapshots.

#### position

[Section titled “position”](#position)

> **position**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

World-space placement anchor after elevation and local offsets.

#### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean` = `false`

Whether the placement depends on local-only EXTRA assets.

#### rotationRadians

[Section titled “rotationRadians”](#rotationradians)

> **rotationRadians**: `number` = `0`

Rotation in radians derived from `rotationSteps`.

#### rotationSteps

[Section titled “rotationSteps”](#rotationsteps)

> **rotationSteps**: `number` = `0`

Clockwise 60-degree rotation steps.

#### scale

[Section titled “scale”](#scale)

> **scale**: `number` = `1`

Uniform render scale.

#### stackIndex

[Section titled “stackIndex”](#stackindex)

> **stackIndex**: `number` | `undefined`

Optional stack index for layered terrain and vertical props.

#### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

KayKit texture set applied to this placement.

#### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string` = `''`

Origin tile key in `q,r` form.

***

### placements

[Section titled “placements”](#placements)

> **placements**: readonly `object`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:234](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L234)

Placements on the resolved tile.

***

### tileKey?

[Section titled “tileKey?”](#tilekey-1)

> `optional` **tileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:228](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L228)

Resolved tile key, when any target is on a tile.

# GameboardInteropEntity

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:82](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L82)

Portable ECS-style entity with named components.

## Properties

[Section titled “Properties”](#properties)

### components

[Section titled “components”](#components)

> **components**: `Readonly`<`Record`<`string`, `unknown`>>

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L88)

Component payloads keyed by component name.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:84](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L84)

Stable entity id.

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardInteropEntityKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteropentitykind/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L86)

Entity kind.

# GameboardInteropOptions

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:448](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L448)

Options for base plan interop snapshots.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`GameboardScenarioInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariointeropoptions/)
* [`GameboardSimulationInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardsimulationinteropoptions/)
* [`GameboardRuntimeInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimeinteropoptions/)
* [`GameboardRuntimeSnapshotOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimesnapshotoptions/)

## Properties

[Section titled “Properties”](#properties)

### includePlacements?

[Section titled “includePlacements?”](#includeplacements)

> `optional` **includePlacements?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:450](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L450)

Include placement entities and relations. Defaults to true.

***

### spawnLocations?

[Section titled “spawnLocations?”](#spawnlocations)

> `optional` **spawnLocations?**: `Omit`<[`SpawnLocationOptions`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocationoptions/), `"shape"`>

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:452](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L452)

Optional spawn-location generation options.

# GameboardInteropRelationFilter

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:436](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L436)

Filter used to select interop relations.

## Properties

[Section titled “Properties”](#properties)

### fromId?

[Section titled “fromId?”](#fromid)

> `optional` **fromId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:440](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L440)

Source entity id to include.

***

### name?

[Section titled “name?”](#name)

> `optional` **name?**: [`GameboardEcsRelationName`](/declarative-hex-worlds/reference/index/type-aliases/gameboardecsrelationname/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:438](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L438)

Relation name to include.

***

### toId?

[Section titled “toId?”](#toid)

> `optional` **toId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:442](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L442)

Target entity id to include.

# GameboardInteropScenarioRecord

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:323](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L323)

Scenario metadata embedded in an interop snapshot.

## Properties

[Section titled “Properties”](#properties)

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:325](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L325)

Scenario id.

***

### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:329](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L329)

Serializable scenario metadata.

***

### title?

[Section titled “title?”](#title)

> `optional` **title?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:327](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L327)

Scenario title.

# GameboardInteropSnapshot

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:400](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L400)

Portable interop snapshot containing entities, relations, and spawn locations.

## Properties

[Section titled “Properties”](#properties)

### adjacency

[Section titled “adjacency”](#adjacency)

> **adjacency**: readonly [`GameboardAdjacencyRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardadjacencyrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:410](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L410)

Tile adjacency records.

***

### entities

[Section titled “entities”](#entities)

> **entities**: readonly [`GameboardInteropEntity`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropentity/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:408](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L408)

Portable interop entities.

***

### relations

[Section titled “relations”](#relations)

> **relations**: readonly [`GameboardEcsRelation`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsrelation/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:412](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L412)

ECS relation records.

***

### scenario?

[Section titled “scenario?”](#scenario)

> `optional` **scenario?**: [`GameboardInteropScenarioRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropscenariorecord/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:406](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L406)

Optional scenario metadata.

***

### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> **schemaVersion**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:402](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L402)

Snapshot schema version.

***

### seed

[Section titled “seed”](#seed)

> **seed**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:404](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L404)

Plan or scenario seed.

***

### spawnLocations

[Section titled “spawnLocations”](#spawnlocations)

> **spawnLocations**: readonly [`SpawnLocation`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocation/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:414](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L414)

Spawn locations included in the snapshot.

# GameboardInteropSnapshotIndex

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:420](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L420)

Indexes for fast relation and entity lookup from an interop snapshot.

## Properties

[Section titled “Properties”](#properties)

### entitiesById

[Section titled “entitiesById”](#entitiesbyid)

> **entitiesById**: `ReadonlyMap`<`string`, [`GameboardInteropEntity`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropentity/)>

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:422](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L422)

Entities keyed by id.

***

### relations

[Section titled “relations”](#relations)

> **relations**: readonly [`GameboardEcsRelation`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsrelation/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:424](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L424)

All relations.

***

### relationsByName

[Section titled “relationsByName”](#relationsbyname)

> **relationsByName**: `ReadonlyMap`<[`GameboardEcsRelationName`](/declarative-hex-worlds/reference/index/type-aliases/gameboardecsrelationname/), readonly [`GameboardEcsRelation`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsrelation/)\[]>

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:426](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L426)

Relations grouped by relation name.

***

### relationsFromId

[Section titled “relationsFromId”](#relationsfromid)

> **relationsFromId**: `ReadonlyMap`<`string`, readonly [`GameboardEcsRelation`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsrelation/)\[]>

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:428](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L428)

Relations grouped by source id.

***

### relationsToId

[Section titled “relationsToId”](#relationstoid)

> **relationsToId**: `ReadonlyMap`<`string`, readonly [`GameboardEcsRelation`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsrelation/)\[]>

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:430](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L430)

Relations grouped by target id.

# GameboardMovementAdvanceResult

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:133](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L133)

Result returned after advancing movement.

## Properties

[Section titled “Properties”](#properties)

### entity

[Section titled “entity”](#entity)

> **entity**: `Entity`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:135](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L135)

Movement agent entity.

***

### moved

[Section titled “moved”](#moved)

> **moved**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:143](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L143)

Whether the placement moved during this advance call.

***

### placement

[Section titled “placement”](#placement)

> **placement**: `object`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:137](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L137)

Placement state after advancement.

#### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string` = `''`

Manifest or external registry asset id.

#### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Axial coordinates of the origin tile.

#### elevation

[Section titled “elevation”](#elevation)

> **elevation**: `number` = `0`

Base tile elevation where the placement was spawned.

#### elevationOffset

[Section titled “elevationOffset”](#elevationoffset)

> **elevationOffset**: `number` = `0`

Extra vertical offset above the tile elevation.

#### id

[Section titled “id”](#id)

> **id**: `string` = `''`

Stable placement id.

#### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Gameplay category for rules, selectors, and rendering.

#### layer

[Section titled “layer”](#layer)

> **layer**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Render and occupancy layer.

#### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Record`<`string`, `string` | `number` | `boolean` | `null`>

Serializable placement metadata for rules, ECS interop, and render hints.

#### order

[Section titled “order”](#order)

> **order**: `number` = `0`

Stable sort order used by renderers and snapshots.

#### position

[Section titled “position”](#position)

> **position**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

World-space placement anchor after elevation and local offsets.

#### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean` = `false`

Whether the placement depends on local-only EXTRA assets.

#### rotationRadians

[Section titled “rotationRadians”](#rotationradians)

> **rotationRadians**: `number` = `0`

Rotation in radians derived from `rotationSteps`.

#### rotationSteps

[Section titled “rotationSteps”](#rotationsteps)

> **rotationSteps**: `number` = `0`

Clockwise 60-degree rotation steps.

#### scale

[Section titled “scale”](#scale)

> **scale**: `number` = `1`

Uniform render scale.

#### stackIndex

[Section titled “stackIndex”](#stackindex)

> **stackIndex**: `number` | `undefined`

Optional stack index for layered terrain and vertical props.

#### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

KayKit texture set applied to this placement.

#### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string` = `''`

Origin tile key in `q,r` form.

***

### profile

[Section titled “profile”](#profile)

> **profile**: [`GameboardMovementProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementprofile/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:139](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L139)

Resolved movement profile.

***

### state

[Section titled “state”](#state)

> **state**: `object`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:141](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L141)

Movement path state after advancement.

#### cost

[Section titled “cost”](#cost)

> **cost**: `number` = `0`

Total planned path cost.

#### destinationKey

[Section titled “destinationKey”](#destinationkey)

> **destinationKey**: `string` = `''`

Destination tile key for the current request.

#### nextIndex

[Section titled “nextIndex”](#nextindex)

> **nextIndex**: `number` = `0`

Next path index to advance to.

#### pathKeys

[Section titled “pathKeys”](#pathkeys)

> **pathKeys**: `string`\[]

Planned path tile keys.

#### reason

[Section titled “reason”](#reason)

> **reason**: `string` | `undefined`

Blocked or out-of-range reason.

#### spentCost

[Section titled “spentCost”](#spentcost)

> **spentCost**: `number` = `0`

Cost spent so far.

#### status

[Section titled “status”](#status)

> **status**: [`GameboardMovementStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementstatus/)

Current movement status.

#### visited

[Section titled “visited”](#visited)

> **visited**: `number` = `0`

Number of pathfinder nodes visited for the request.

# GameboardMovementBlockedEvent

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:163](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L163)

Movement system could not advance a path.

## Properties

[Section titled “Properties”](#properties)

### movement

[Section titled “movement”](#movement)

> **movement**: [`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:167](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L167)

Movement advancement result.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:169](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L169)

Blocked reason.

***

### type

[Section titled “type”](#type)

> **type**: `"movement-blocked"`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:165](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L165)

Event discriminator.

# GameboardMovementCompletedEvent

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:153](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L153)

Movement system completed a path.

## Properties

[Section titled “Properties”](#properties)

### movement

[Section titled “movement”](#movement)

> **movement**: [`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:157](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L157)

Movement advancement result.

***

### type

[Section titled “type”](#type)

> **type**: `"movement-completed"`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:155](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L155)

Event discriminator.

# GameboardMovementEventRecord

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:284](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L284)

Serializable movement event record.

## Properties

[Section titled “Properties”](#properties)

### actorId?

[Section titled “actorId?”](#actorid)

> `optional` **actorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:288](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L288)

Actor id when the moved placement is actor-backed.

***

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:292](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L292)

Placement asset id.

***

### moved

[Section titled “moved”](#moved)

> **moved**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:296](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L296)

Whether the placement moved during this event.

***

### placementId

[Section titled “placementId”](#placementid)

> **placementId**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:286](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L286)

Placement id being moved.

***

### profileId

[Section titled “profileId”](#profileid)

> **profileId**: [`GameboardMovementProfileId`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementprofileid/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:294](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L294)

Movement profile id used for the move.

***

### state

[Section titled “state”](#state)

> **state**: `object`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:298](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L298)

Snapshot of the path state.

#### cost

[Section titled “cost”](#cost)

> **cost**: `number` = `0`

Total planned path cost.

#### destinationKey

[Section titled “destinationKey”](#destinationkey)

> **destinationKey**: `string` = `''`

Destination tile key for the current request.

#### nextIndex

[Section titled “nextIndex”](#nextindex)

> **nextIndex**: `number` = `0`

Next path index to advance to.

#### pathKeys

[Section titled “pathKeys”](#pathkeys)

> **pathKeys**: `string`\[]

Planned path tile keys.

#### reason

[Section titled “reason”](#reason)

> **reason**: `string` | `undefined`

Blocked or out-of-range reason.

#### spentCost

[Section titled “spentCost”](#spentcost)

> **spentCost**: `number` = `0`

Cost spent so far.

#### status

[Section titled “status”](#status)

> **status**: [`GameboardMovementStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementstatus/)

Current movement status.

#### visited

[Section titled “visited”](#visited)

> **visited**: `number` = `0`

Number of pathfinder nodes visited for the request.

***

### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:290](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L290)

Current tile key for the moved placement.

# GameboardMovementOptions

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:77](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L77)

Shared options for actor/placement movement helpers.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`SetGameboardMovementAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardmovementagentoptions/)
* [`GameboardMovementPathRequestOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementpathrequestoptions/)
* [`AdvanceGameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardmovementoptions/)

## Properties

[Section titled “Properties”](#properties)

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:85](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L85)

Placement ids ignored during pathing.

***

### movementBudget?

[Section titled “movementBudget?”](#movementbudget)

> `optional` **movementBudget?**: `number`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:83](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L83)

Movement budget override.

***

### navigation?

[Section titled “navigation?”](#navigation)

> `optional` **navigation?**: [`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:87](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L87)

Navigation profile overrides merged over the movement profile.

***

### profile?

[Section titled “profile?”](#profile)

> `optional` **profile?**: [`GameboardMovementProfileInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardmovementprofileinput/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:79](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L79)

Movement profile id or inline profile.

***

### profiles?

[Section titled “profiles?”](#profiles)

> `optional` **profiles?**: [`GameboardMovementProfileRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementprofileregistry/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:81](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L81)

Registry used to resolve profile ids.

# GameboardMovementPathRequestOptions

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:101](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L101)

Options for requesting a path for a movement agent.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/)

## Properties

[Section titled “Properties”](#properties)

### allowOutOfRangePath?

[Section titled “allowOutOfRangePath?”](#allowoutofrangepath)

> `optional` **allowOutOfRangePath?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:103](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L103)

Keep a found path even when it exceeds the current budget.

***

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:85](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L85)

Placement ids ignored during pathing.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/).[`ignorePlacementIds`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/#ignoreplacementids)

***

### movementBudget?

[Section titled “movementBudget?”](#movementbudget)

> `optional` **movementBudget?**: `number`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:83](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L83)

Movement budget override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/).[`movementBudget`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/#movementbudget)

***

### navigation?

[Section titled “navigation?”](#navigation)

> `optional` **navigation?**: [`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:87](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L87)

Navigation profile overrides merged over the movement profile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/).[`navigation`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/#navigation)

***

### profile?

[Section titled “profile?”](#profile)

> `optional` **profile?**: [`GameboardMovementProfileInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardmovementprofileinput/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:79](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L79)

Movement profile id or inline profile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/).[`profile`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/#profile)

***

### profiles?

[Section titled “profiles?”](#profiles)

> `optional` **profiles?**: [`GameboardMovementProfileRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementprofileregistry/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:81](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L81)

Registry used to resolve profile ids.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/).[`profiles`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/#profiles)

# GameboardMovementProfile

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:50](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L50)

Movement profile combining a movement budget with a navigation profile.

## Properties

[Section titled “Properties”](#properties)

### id

[Section titled “id”](#id)

> **id**: [`GameboardMovementProfileId`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementprofileid/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:52](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L52)

Stable profile id.

***

### label

[Section titled “label”](#label)

> **label**: `string`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:54](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L54)

Human-readable label.

***

### movementBudget

[Section titled “movementBudget”](#movementbudget)

> **movementBudget**: `number`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:56](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L56)

Default movement budget for one movement cycle.

***

### navigation

[Section titled “navigation”](#navigation)

> **navigation**: [`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L58)

Navigation profile used by this movement profile.

# GameboardMovementProfileRegistry

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:69](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L69)

Movement profiles keyed by id.

## Indexable

[Section titled “Indexable”](#indexable)

> \[`profileId`: `string`]: [`GameboardMovementProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementprofile/)

Movement profile for the profile id key.

# GameboardMovementRequestedEvent

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L47)

Command execution requested a movement path.

## Properties

[Section titled “Properties”](#properties)

### execution

[Section titled “execution”](#execution)

> **execution**: [`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:51](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L51)

Command execution that produced the movement request.

***

### type

[Section titled “type”](#type)

> **type**: `"movement-requested"`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:49](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L49)

Event discriminator.

# GameboardMovementRequestResult

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:117](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L117)

Result returned after requesting movement.

## Properties

[Section titled “Properties”](#properties)

### entity

[Section titled “entity”](#entity)

> **entity**: `Entity`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:119](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L119)

Movement agent entity.

***

### path

[Section titled “path”](#path)

> **path**: [`GameboardNavigationPathResult`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationpathresult/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:125](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L125)

Planned path.

***

### placement

[Section titled “placement”](#placement)

> **placement**: `object`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:121](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L121)

Placement state after the request.

#### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string` = `''`

Manifest or external registry asset id.

#### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Axial coordinates of the origin tile.

#### elevation

[Section titled “elevation”](#elevation)

> **elevation**: `number` = `0`

Base tile elevation where the placement was spawned.

#### elevationOffset

[Section titled “elevationOffset”](#elevationoffset)

> **elevationOffset**: `number` = `0`

Extra vertical offset above the tile elevation.

#### id

[Section titled “id”](#id)

> **id**: `string` = `''`

Stable placement id.

#### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Gameplay category for rules, selectors, and rendering.

#### layer

[Section titled “layer”](#layer)

> **layer**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Render and occupancy layer.

#### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Record`<`string`, `string` | `number` | `boolean` | `null`>

Serializable placement metadata for rules, ECS interop, and render hints.

#### order

[Section titled “order”](#order)

> **order**: `number` = `0`

Stable sort order used by renderers and snapshots.

#### position

[Section titled “position”](#position)

> **position**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

World-space placement anchor after elevation and local offsets.

#### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean` = `false`

Whether the placement depends on local-only EXTRA assets.

#### rotationRadians

[Section titled “rotationRadians”](#rotationradians)

> **rotationRadians**: `number` = `0`

Rotation in radians derived from `rotationSteps`.

#### rotationSteps

[Section titled “rotationSteps”](#rotationsteps)

> **rotationSteps**: `number` = `0`

Clockwise 60-degree rotation steps.

#### scale

[Section titled “scale”](#scale)

> **scale**: `number` = `1`

Uniform render scale.

#### stackIndex

[Section titled “stackIndex”](#stackindex)

> **stackIndex**: `number` | `undefined`

Optional stack index for layered terrain and vertical props.

#### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

KayKit texture set applied to this placement.

#### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string` = `''`

Origin tile key in `q,r` form.

***

### profile

[Section titled “profile”](#profile)

> **profile**: [`GameboardMovementProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementprofile/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:123](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L123)

Resolved movement profile.

***

### state

[Section titled “state”](#state)

> **state**: `object`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:127](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L127)

Movement path state written to the entity.

#### cost

[Section titled “cost”](#cost)

> **cost**: `number` = `0`

Total planned path cost.

#### destinationKey

[Section titled “destinationKey”](#destinationkey)

> **destinationKey**: `string` = `''`

Destination tile key for the current request.

#### nextIndex

[Section titled “nextIndex”](#nextindex)

> **nextIndex**: `number` = `0`

Next path index to advance to.

#### pathKeys

[Section titled “pathKeys”](#pathkeys)

> **pathKeys**: `string`\[]

Planned path tile keys.

#### reason

[Section titled “reason”](#reason)

> **reason**: `string` | `undefined`

Blocked or out-of-range reason.

#### spentCost

[Section titled “spentCost”](#spentcost)

> **spentCost**: `number` = `0`

Cost spent so far.

#### status

[Section titled “status”](#status)

> **status**: [`GameboardMovementStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementstatus/)

Current movement status.

#### visited

[Section titled “visited”](#visited)

> **visited**: `number` = `0`

Number of pathfinder nodes visited for the request.

# GameboardMovementSteppedEvent

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:143](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L143)

Movement system advanced a placement along a path.

## Properties

[Section titled “Properties”](#properties)

### movement

[Section titled “movement”](#movement)

> **movement**: [`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:147](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L147)

Movement advancement result.

***

### type

[Section titled “type”](#type)

> **type**: `"movement-stepped"`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:145](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L145)

Event discriminator.

# GameboardNeighborhoodInspection

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:345](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L345)

Actor-aware inspection for a ring or radius around a center tile.

## Properties

[Section titled “Properties”](#properties)

### actors

[Section titled “actors”](#actors)

> **actors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:355](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L355)

Unique actors found in matching tiles.

***

### blockingTileKeys

[Section titled “blockingTileKeys”](#blockingtilekeys)

> **blockingTileKeys**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:367](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L367)

Tile keys with blocking placements.

***

### center

[Section titled “center”](#center)

> **center**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:347](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L347)

Resolved center coordinates.

***

### centerKey

[Section titled “centerKey”](#centerkey)

> **centerKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:349](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L349)

Resolved center tile key.

***

### enterableTileKeys

[Section titled “enterableTileKeys”](#enterabletilekeys)

> **enterableTileKeys**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:363](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L363)

Tile keys that can be entered.

***

### hostileActors

[Section titled “hostileActors”](#hostileactors)

> **hostileActors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:357](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L357)

Unique hostile actors found in matching tiles.

***

### interactiveActors

[Section titled “interactiveActors”](#interactiveactors)

> **interactiveActors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:359](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L359)

Unique interactive actors found in matching tiles.

***

### occupiedTileKeys

[Section titled “occupiedTileKeys”](#occupiedtilekeys)

> **occupiedTileKeys**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:365](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L365)

Tile keys with gameplay occupancy.

***

### propActors

[Section titled “propActors”](#propactors)

> **propActors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:361](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L361)

Unique prop actors found in matching tiles.

***

### radius

[Section titled “radius”](#radius)

> **radius**: `number`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:351](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L351)

Normalized inspection radius.

***

### tiles

[Section titled “tiles”](#tiles)

> **tiles**: readonly [`GameboardNeighborhoodTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodtileinspection/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:353](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L353)

Matching tile inspections sorted by distance and tile key.

# GameboardNeighborhoodInspectionOptions

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:309](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L309)

Filters and options for actor-aware neighborhood inspection.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/)

## Properties

[Section titled “Properties”](#properties)

### blockingPlacementKinds?

[Section titled “blockingPlacementKinds?”](#blockingplacementkinds)

> `optional` **blockingPlacementKinds?**: readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L126)

Placement kinds that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/).[`blockingPlacementKinds`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/#blockingplacementkinds)

***

### blockingPlacementLayers?

[Section titled “blockingPlacementLayers?”](#blockingplacementlayers)

> `optional` **blockingPlacementLayers?**: readonly [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L128)

Placement layers that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/).[`blockingPlacementLayers`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/#blockingplacementlayers)

***

### canEnter?

[Section titled “canEnter?”](#canenter)

> `optional` **canEnter?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:323](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L323)

Filter by enterable state.

***

### excludeTileTags?

[Section titled “excludeTileTags?”](#excludetiletags)

> `optional` **excludeTileTags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:321](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L321)

Tile tags that must be absent.

***

### hasActors?

[Section titled “hasActors?”](#hasactors)

> `optional` **hasActors?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:325](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L325)

Filter by actor presence.

***

### hasHostiles?

[Section titled “hasHostiles?”](#hashostiles)

> `optional` **hasHostiles?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:327](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L327)

Filter by hostile actor presence.

***

### hasInteractive?

[Section titled “hasInteractive?”](#hasinteractive)

> `optional` **hasInteractive?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:329](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L329)

Filter by interactive actor presence.

***

### hasProps?

[Section titled “hasProps?”](#hasprops)

> `optional` **hasProps?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:331](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L331)

Filter by prop actor presence.

***

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L130)

Placement ids ignored during collision checks.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/).[`ignorePlacementIds`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/#ignoreplacementids)

***

### includeCenter?

[Section titled “includeCenter?”](#includecenter)

> `optional` **includeCenter?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:313](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L313)

Include the center tile in results. Defaults to true.

***

### includeMissing?

[Section titled “includeMissing?”](#includemissing)

> `optional` **includeMissing?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:315](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L315)

Include missing tiles in results. Defaults to false.

***

### radius?

[Section titled “radius?”](#radius)

> `optional` **radius?**: `number`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:311](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L311)

Hex radius around the center. Defaults to `1`.

***

### sourceActor?

[Section titled “sourceActor?”](#sourceactor)

> `optional` **sourceActor?**: `string` | `Entity`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:248](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L248)

Source actor used for collision interpretation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/).[`sourceActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/#sourceactor)

***

### terrain?

[Section titled “terrain?”](#terrain)

> `optional` **terrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/) | readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:317](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L317)

Required terrain or accepted terrains.

***

### tileTags?

[Section titled “tileTags?”](#tiletags)

> `optional` **tileTags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:319](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L319)

Required tile tags.

***

### treatHostileAsBlocking?

[Section titled “treatHostileAsBlocking?”](#treathostileasblocking)

> `optional` **treatHostileAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:132](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L132)

Treat hostile actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/).[`treatHostileAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/#treathostileasblocking)

***

### treatInteractiveAsBlocking?

[Section titled “treatInteractiveAsBlocking?”](#treatinteractiveasblocking)

> `optional` **treatInteractiveAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L134)

Treat interactive actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/).[`treatInteractiveAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/#treatinteractiveasblocking)

***

### treatPropsAsBlocking?

[Section titled “treatPropsAsBlocking?”](#treatpropsasblocking)

> `optional` **treatPropsAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L136)

Treat prop actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/).[`treatPropsAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/#treatpropsasblocking)

# GameboardNeighborhoodTileInspection

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:337](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L337)

Tile inspection with distance from the inspected neighborhood center.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

## Properties

[Section titled “Properties”](#properties)

### actors

[Section titled “actors”](#actors)

> **actors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:274](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L274)

Actor placements on the tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`actors`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#actors)

***

### blockingPlacements

[Section titled “blockingPlacements”](#blockingplacements)

> **blockingPlacements**: readonly `object`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:282](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L282)

Placements that block movement onto the tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`blockingPlacements`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#blockingplacements)

***

### canEnter

[Section titled “canEnter”](#canenter)

> **canEnter**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:286](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L286)

Whether the tile exists and can be entered.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`canEnter`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#canenter)

***

### collision

[Section titled “collision”](#collision)

> **collision**: [`GameboardActorCollisionReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionreport/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:284](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L284)

Full collision report for the tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`collision`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#collision)

***

### coordinates?

[Section titled “coordinates?”](#coordinates)

> `optional` **coordinates?**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:262](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L262)

Axial coordinates, when the tile exists.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`coordinates`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#coordinates)

***

### distance

[Section titled “distance”](#distance)

> **distance**: `number`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:339](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L339)

Hex distance from the neighborhood center.

***

### elevation?

[Section titled “elevation?”](#elevation)

> `optional` **elevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:266](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L266)

Tile elevation, when the tile exists.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`elevation`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#elevation)

***

### exists

[Section titled “exists”](#exists)

> **exists**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:256](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L256)

Whether the tile exists in the board.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`exists`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#exists)

***

### hasActors

[Section titled “hasActors”](#hasactors)

> **hasActors**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:290](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L290)

Whether any actors occupy the tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`hasActors`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#hasactors)

***

### hasHostiles

[Section titled “hasHostiles”](#hashostiles)

> **hasHostiles**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:292](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L292)

Whether any hostile actors occupy the tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`hasHostiles`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#hashostiles)

***

### hasInteractive

[Section titled “hasInteractive”](#hasinteractive)

> **hasInteractive**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:294](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L294)

Whether any interactive actors occupy the tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`hasInteractive`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#hasinteractive)

***

### hasProps

[Section titled “hasProps”](#hasprops)

> **hasProps**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:296](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L296)

Whether any prop actors occupy the tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`hasProps`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#hasprops)

***

### hostileActors

[Section titled “hostileActors”](#hostileactors)

> **hostileActors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:276](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L276)

Hostile actors on the tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`hostileActors`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#hostileactors)

***

### interactiveActors

[Section titled “interactiveActors”](#interactiveactors)

> **interactiveActors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:278](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L278)

Interactive actors on the tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`interactiveActors`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#interactiveactors)

***

### isEmpty

[Section titled “isEmpty”](#isempty)

> **isEmpty**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:288](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L288)

Whether no placements occupy the tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`isEmpty`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#isempty)

***

### occupancy

[Section titled “occupancy”](#occupancy)

> **occupancy**: readonly [`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:272](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L272)

Occupancy relation records for the tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-14)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`occupancy`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#occupancy)

***

### placements

[Section titled “placements”](#placements)

> **placements**: readonly `object`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:270](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L270)

Placements occupying the tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-15)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`placements`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#placements)

***

### propActors

[Section titled “propActors”](#propactors)

> **propActors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:280](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L280)

Prop actors on the tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-16)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`propActors`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#propactors)

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:298](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L298)

Missing or blocked reason.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-17)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`reason`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#reason)

***

### tags

[Section titled “tags”](#tags)

> **tags**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:268](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L268)

Tile tags, or an empty list for missing tiles.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-18)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`tags`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#tags)

***

### terrain?

[Section titled “terrain?”](#terrain)

> `optional` **terrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:264](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L264)

Tile terrain, when the tile exists.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-19)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`terrain`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#terrain)

***

### tile?

[Section titled “tile?”](#tile)

> `optional` **tile?**: `object`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:260](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L260)

Tile trait value, when the tile exists.

#### baseAssetId

[Section titled “baseAssetId”](#baseassetid)

> **baseAssetId**: `string` = `''`

Asset id for the visible tile top.

#### coastEdges

[Section titled “coastEdges”](#coastedges)

> **coastEdges**: `number` = `0`

Six-edge bitmask for coast connectivity.

#### coastWaterless

[Section titled “coastWaterless”](#coastwaterless)

> **coastWaterless**: `boolean` = `false`

Whether this coast tile uses the waterless guide variant.

#### coordinates

[Section titled “coordinates”](#coordinates-1)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Axial tile coordinates.

#### elevation

[Section titled “elevation”](#elevation-1)

> **elevation**: `number` = `0`

Stacked elevation level for the tile top.

#### key

[Section titled “key”](#key)

> **key**: `string` = `''`

Stable axial key in `q,r` form.

#### riverCrossing

[Section titled “riverCrossing”](#rivercrossing)

> **riverCrossing**: `"A"` | `"B"` | `undefined`

River crossing variant, when present.

#### riverCurvy

[Section titled “riverCurvy”](#rivercurvy)

> **riverCurvy**: `boolean` = `false`

Whether this river tile uses the curvy guide variant.

#### riverEdges

[Section titled “riverEdges”](#riveredges)

> **riverEdges**: `number` = `0`

Six-edge bitmask for river connectivity.

#### riverWaterless

[Section titled “riverWaterless”](#riverwaterless)

> **riverWaterless**: `boolean` = `false`

Whether this river tile uses the waterless guide variant.

#### roadEdges

[Section titled “roadEdges”](#roadedges)

> **roadEdges**: `number` = `0`

Six-edge bitmask for road connectivity.

#### roadSlope

[Section titled “roadSlope”](#roadslope)

> **roadSlope**: `"high"` | `"low"` | `undefined`

Road slope variant when a road changes elevation.

#### supportAssetId

[Section titled “supportAssetId”](#supportassetid)

> **supportAssetId**: `string` = `''`

Optional asset id for the vertical support below elevated tiles.

#### tags

[Section titled “tags”](#tags-1)

> **tags**: `string`\[]

Free-form taxonomy and generation tags.

#### terrain

[Section titled “terrain”](#terrain-1)

> **terrain**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)

Primary terrain biome represented by this tile.

#### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

KayKit texture set applied to this tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-20)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`tile`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#tile)

***

### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:258](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L258)

Inspected tile key.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-21)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/).[`tileKey`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/#tilekey)

# GameboardPatrolAdvanceResult

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:101](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L101)

Result returned after advancing a patrol agent.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardPatrolSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/)

## Properties

[Section titled “Properties”](#properties)

### actor?

[Section titled “actor?”](#actor)

> `optional` **actor?**: [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:91](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L91)

Actor snapshot when the patrol placement is registered as an actor.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardPatrolSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/).[`actor`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/#actor)

***

### advanced

[Section titled “advanced”](#advanced)

> **advanced**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:109](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L109)

Whether this advance call completed a waypoint transition.

***

### agent

[Section titled “agent”](#agent)

> **agent**: `object`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:93](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L93)

Patrol agent trait value.

#### active

[Section titled “active”](#active)

> **active**: `boolean` = `true`

Whether the patrol agent is active.

#### currentWaypointIndex

[Section titled “currentWaypointIndex”](#currentwaypointindex)

> **currentWaypointIndex**: `number` = `0`

Current waypoint index.

#### loop

[Section titled “loop”](#loop)

> **loop**: `boolean` = `true`

Whether the route loops back to the first waypoint.

#### pauseTicks

[Section titled “pauseTicks”](#pauseticks)

> **pauseTicks**: `number` = `0`

Ticks to wait after reaching each waypoint.

#### roundsCompleted

[Section titled “roundsCompleted”](#roundscompleted)

> **roundsCompleted**: `number` = `0`

Number of completed route rounds.

#### routeId

[Section titled “routeId”](#routeid)

> **routeId**: `string` = `''`

Route id followed by this patrol.

#### segmentCosts

[Section titled “segmentCosts”](#segmentcosts)

> **segmentCosts**: `number`\[]

Optional movement budget per route segment.

#### targetWaypointIndex

[Section titled “targetWaypointIndex”](#targetwaypointindex)

> **targetWaypointIndex**: `number` = `-1`

Target waypoint index for an in-flight segment.

#### waitTicksRemaining

[Section titled “waitTicksRemaining”](#waitticksremaining)

> **waitTicksRemaining**: `number` = `0`

Remaining wait ticks before the next segment.

#### waypointKeys

[Section titled “waypointKeys”](#waypointkeys)

> **waypointKeys**: `string`\[]

Ordered route waypoint tile keys.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardPatrolSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/).[`agent`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/#agent)

***

### entity

[Section titled “entity”](#entity)

> **entity**: `Entity`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:87](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L87)

Live Koota entity.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardPatrolSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/).[`entity`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/#entity)

***

### movement?

[Section titled “movement?”](#movement)

> `optional` **movement?**: [`GameboardMovementRequestResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementrequestresult/)

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:105](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L105)

Movement request produced during advancement.

***

### placement

[Section titled “placement”](#placement)

> **placement**: `object`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:89](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L89)

Placement state associated with the patrol.

#### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string` = `''`

Manifest or external registry asset id.

#### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Axial coordinates of the origin tile.

#### elevation

[Section titled “elevation”](#elevation)

> **elevation**: `number` = `0`

Base tile elevation where the placement was spawned.

#### elevationOffset

[Section titled “elevationOffset”](#elevationoffset)

> **elevationOffset**: `number` = `0`

Extra vertical offset above the tile elevation.

#### id

[Section titled “id”](#id)

> **id**: `string` = `''`

Stable placement id.

#### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Gameplay category for rules, selectors, and rendering.

#### layer

[Section titled “layer”](#layer)

> **layer**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Render and occupancy layer.

#### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Record`<`string`, `string` | `number` | `boolean` | `null`>

Serializable placement metadata for rules, ECS interop, and render hints.

#### order

[Section titled “order”](#order)

> **order**: `number` = `0`

Stable sort order used by renderers and snapshots.

#### position

[Section titled “position”](#position)

> **position**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

World-space placement anchor after elevation and local offsets.

#### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean` = `false`

Whether the placement depends on local-only EXTRA assets.

#### rotationRadians

[Section titled “rotationRadians”](#rotationradians)

> **rotationRadians**: `number` = `0`

Rotation in radians derived from `rotationSteps`.

#### rotationSteps

[Section titled “rotationSteps”](#rotationsteps)

> **rotationSteps**: `number` = `0`

Clockwise 60-degree rotation steps.

#### scale

[Section titled “scale”](#scale)

> **scale**: `number` = `1`

Uniform render scale.

#### stackIndex

[Section titled “stackIndex”](#stackindex)

> **stackIndex**: `number` | `undefined`

Optional stack index for layered terrain and vertical props.

#### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

KayKit texture set applied to this placement.

#### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string` = `''`

Origin tile key in `q,r` form.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardPatrolSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/).[`placement`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/#placement)

***

### previousState

[Section titled “previousState”](#previousstate)

> **previousState**: `object`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:103](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L103)

Patrol state before advancement.

#### lastPathKeys

[Section titled “lastPathKeys”](#lastpathkeys)

> **lastPathKeys**: `string`\[]

Last requested movement path tile keys.

#### reason

[Section titled “reason”](#reason)

> **reason**: `string` | `undefined`

Blocked or paused reason.

#### status

[Section titled “status”](#status)

> **status**: [`GameboardPatrolStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardpatrolstatus/)

Current patrol status.

#### targetKey

[Section titled “targetKey”](#targetkey)

> **targetKey**: `string` = `''`

Current target waypoint tile key.

***

### requested

[Section titled “requested”](#requested)

> **requested**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:107](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L107)

Whether this advance call requested a new movement segment.

***

### state

[Section titled “state”](#state)

> **state**: `object`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:95](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L95)

Patrol state trait value.

#### lastPathKeys

[Section titled “lastPathKeys”](#lastpathkeys-1)

> **lastPathKeys**: `string`\[]

Last requested movement path tile keys.

#### reason

[Section titled “reason”](#reason-1)

> **reason**: `string` | `undefined`

Blocked or paused reason.

#### status

[Section titled “status”](#status-1)

> **status**: [`GameboardPatrolStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardpatrolstatus/)

Current patrol status.

#### targetKey

[Section titled “targetKey”](#targetkey-1)

> **targetKey**: `string` = `''`

Current target waypoint tile key.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardPatrolSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/).[`state`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/#state)

# GameboardPatrolBlockedEvent

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:131](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L131)

Patrol agent could not advance.

## Properties

[Section titled “Properties”](#properties)

### patrol

[Section titled “patrol”](#patrol)

> **patrol**: [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:135](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L135)

Patrol advancement result.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:137](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L137)

Blocked reason.

***

### type

[Section titled “type”](#type)

> **type**: `"patrol-blocked"`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:133](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L133)

Event discriminator.

# GameboardPatrolCompletedEvent

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:121](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L121)

Patrol agent completed its route or configured rounds.

## Properties

[Section titled “Properties”](#properties)

### patrol

[Section titled “patrol”](#patrol)

> **patrol**: [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:125](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L125)

Patrol advancement result.

***

### type

[Section titled “type”](#type)

> **type**: `"patrol-completed"`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:123](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L123)

Event discriminator.

# GameboardPatrolEventRecord

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:304](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L304)

Serializable patrol event record.

## Properties

[Section titled “Properties”](#properties)

### actorId?

[Section titled “actorId?”](#actorid)

> `optional` **actorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:308](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L308)

Actor id when the patrol placement is actor-backed.

***

### advanced

[Section titled “advanced”](#advanced)

> **advanced**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:324](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L324)

Whether the patrol pointer advanced.

***

### currentWaypointIndex

[Section titled “currentWaypointIndex”](#currentwaypointindex)

> **currentWaypointIndex**: `number`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:316](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L316)

Current waypoint index.

***

### placementId

[Section titled “placementId”](#placementid)

> **placementId**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:306](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L306)

Placement id controlled by the patrol agent.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:326](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L326)

Optional patrol blocked/waiting reason.

***

### requested

[Section titled “requested”](#requested)

> **requested**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:322](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L322)

Whether movement was requested.

***

### roundsCompleted

[Section titled “roundsCompleted”](#roundscompleted)

> **roundsCompleted**: `number`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:320](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L320)

Completed route rounds.

***

### routeId

[Section titled “routeId”](#routeid)

> **routeId**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:310](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L310)

Patrol route id.

***

### status

[Section titled “status”](#status)

> **status**: [`GameboardPatrolStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardpatrolstatus/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:312](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L312)

Patrol status after advancement.

***

### targetKey?

[Section titled “targetKey?”](#targetkey)

> `optional` **targetKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:314](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L314)

Current target waypoint tile key.

***

### targetWaypointIndex

[Section titled “targetWaypointIndex”](#targetwaypointindex)

> **targetWaypointIndex**: `number`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:318](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L318)

Target waypoint index.

# GameboardPatrolMoveRequestedEvent

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:101](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L101)

Patrol system requested movement for a patrol agent.

## Properties

[Section titled “Properties”](#properties)

### patrol

[Section titled “patrol”](#patrol)

> **patrol**: [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:105](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L105)

Patrol advancement result.

***

### type

[Section titled “type”](#type)

> **type**: `"patrol-move-requested"`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:103](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L103)

Event discriminator.

# GameboardPatrolRouteInput

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:41](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L41)

Lightweight patrol route input accepted by patrol agents.

## Properties

[Section titled “Properties”](#properties)

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:43](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L43)

Stable route id.

***

### loop?

[Section titled “loop?”](#loop)

> `optional` **loop?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L47)

Whether the route loops back to the first waypoint.

***

### segmentCosts?

[Section titled “segmentCosts?”](#segmentcosts)

> `optional` **segmentCosts?**: readonly `number`\[]

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:49](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L49)

Optional movement budget per route segment.

***

### waypointKeys

[Section titled “waypointKeys”](#waypointkeys)

> **waypointKeys**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L45)

Ordered waypoint tile keys.

# GameboardPatrolRouteRecord

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:193](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L193)

Interop record for one patrol route.

## Properties

[Section titled “Properties”](#properties)

### cost

[Section titled “cost”](#cost)

> **cost**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:205](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L205)

Total route cost.

***

### errors

[Section titled “errors”](#errors)

> **errors**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:213](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L213)

Fatal route diagnostics.

***

### found

[Section titled “found”](#found)

> **found**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:203](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L203)

Whether all required route segments were found.

***

### loop

[Section titled “loop”](#loop)

> **loop**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:201](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L201)

Whether the route loops.

***

### pathKeys

[Section titled “pathKeys”](#pathkeys)

> **pathKeys**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:209](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L209)

Combined path tile keys.

***

### requestedWaypointCount

[Section titled “requestedWaypointCount”](#requestedwaypointcount)

> **requestedWaypointCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:197](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L197)

Requested waypoint count.

***

### routeId

[Section titled “routeId”](#routeid)

> **routeId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:195](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L195)

Patrol route id.

***

### selectedWaypointCount

[Section titled “selectedWaypointCount”](#selectedwaypointcount)

> **selectedWaypointCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:199](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L199)

Selected waypoint count.

***

### visited

[Section titled “visited”](#visited)

> **visited**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:207](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L207)

Total pathfinder visits.

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:211](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L211)

Non-fatal route diagnostics.

# GameboardPatrolRouteSegmentRecord

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:241](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L241)

Interop record for one patrol route segment.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardPatrolRouteSegment`](/declarative-hex-worlds/reference/gameboard/navigation/type-aliases/gameboardpatrolroutesegment/)

## Properties

[Section titled “Properties”](#properties)

### cost

[Section titled “cost”](#cost)

> **cost**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts:61](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts#L61)

Segment path cost.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

`GameboardPatrolRouteSegment.cost`

***

### found

[Section titled “found”](#found)

> **found**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts:57](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts#L57)

Whether this segment was found.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

`GameboardPatrolRouteSegment.found`

***

### fromIndex

[Section titled “fromIndex”](#fromindex)

> **fromIndex**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts:49](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts#L49)

Source waypoint index.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

`GameboardPatrolRouteSegment.fromIndex`

***

### fromKey?

[Section titled “fromKey?”](#fromkey)

> `optional` **fromKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts:53](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts#L53)

Source tile key.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

`GameboardPatrolRouteSegment.fromKey`

***

### pathKeys

[Section titled “pathKeys”](#pathkeys)

> **pathKeys**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts:59](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts#L59)

Path tile keys for this segment.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

`GameboardPatrolRouteSegment.pathKeys`

***

### routeId

[Section titled “routeId”](#routeid)

> **routeId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:243](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L243)

Patrol route id.

***

### segmentId

[Section titled “segmentId”](#segmentid)

> **segmentId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:245](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L245)

Segment entity id.

***

### toIndex

[Section titled “toIndex”](#toindex)

> **toIndex**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts:51](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts#L51)

Target waypoint index.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

`GameboardPatrolRouteSegment.toIndex`

***

### toKey?

[Section titled “toKey?”](#tokey)

> `optional` **toKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts:55](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts#L55)

Target tile key.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

`GameboardPatrolRouteSegment.toKey`

***

### visited

[Section titled “visited”](#visited)

> **visited**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts:63](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts#L63)

Number of nodes visited by the pathfinder.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

`GameboardPatrolRouteSegment.visited`

# GameboardPatrolSimulationActorAssignment

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:606](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L606)

Assignment for turning one patrol route into simulation command steps.

## Properties

[Section titled “Properties”](#properties)

### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:610](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L610)

Actor id that should follow the route.

***

### command?

[Section titled “command?”](#command)

> `optional` **command?**: `Omit`<[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/), `"sourceActor"` | `"systems"`>

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:618](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L618)

Command options for generated movement commands.

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:616](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L616)

Base label for generated steps.

***

### movement?

[Section titled “movement?”](#movement)

> `optional` **movement?**: [`GameboardMovementPathRequestOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementpathrequestoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:620](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L620)

Movement path options for generated movement commands.

***

### rounds?

[Section titled “rounds?”](#rounds)

> `optional` **rounds?**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:612](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L612)

Number of route rounds to emit.

***

### routeId

[Section titled “routeId”](#routeid)

> **routeId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:608](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L608)

Patrol route id to execute.

***

### stepIdPrefix?

[Section titled “stepIdPrefix?”](#stepidprefix)

> `optional` **stepIdPrefix?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:614](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L614)

Prefix for generated step ids.

***

### systems?

[Section titled “systems?”](#systems)

> `optional` **systems?**: `false` | [`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:622](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L622)

Systems to run after generated movement commands, or false to skip.

# GameboardPatrolSimulationAssignmentPlan

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:640](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L640)

Report for one patrol simulation assignment.

## Properties

[Section titled “Properties”](#properties)

### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:644](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L644)

Actor id.

***

### errorCount

[Section titled “errorCount”](#errorcount)

> **errorCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:652](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L652)

Error count.

***

### errors

[Section titled “errors”](#errors)

> **errors**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:656](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L656)

Assignment errors.

***

### roundCount

[Section titled “roundCount”](#roundcount)

> **roundCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:646](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L646)

Number of route rounds emitted.

***

### routeId

[Section titled “routeId”](#routeid)

> **routeId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:642](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L642)

Patrol route id.

***

### stepCount

[Section titled “stepCount”](#stepcount)

> **stepCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:648](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L648)

Number of command steps emitted.

***

### warningCount

[Section titled “warningCount”](#warningcount)

> **warningCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:650](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L650)

Warning count.

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:654](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L654)

Assignment warnings.

# GameboardPatrolSimulationScriptPlan

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:697](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L697)

Generated simulation script plus assignment diagnostics.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardPatrolSimulationStepsPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationstepsplan/)

## Properties

[Section titled “Properties”](#properties)

### assignments

[Section titled “assignments”](#assignments)

> **assignments**: readonly [`GameboardPatrolSimulationAssignmentPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationassignmentplan/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:666](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L666)

Assignment diagnostics.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardPatrolSimulationStepsPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationstepsplan/).[`assignments`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationstepsplan/#assignments)

***

### errors

[Section titled “errors”](#errors)

> **errors**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:672](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L672)

Plan-level errors.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardPatrolSimulationStepsPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationstepsplan/).[`errors`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationstepsplan/#errors)

***

### script

[Section titled “script”](#script)

> **script**: [`GameboardScenarioSimulationScript`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationscript/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:699](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L699)

Generated simulation script.

***

### stepCount

[Section titled “stepCount”](#stepcount)

> **stepCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:664](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L664)

Total generated step count.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardPatrolSimulationStepsPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationstepsplan/).[`stepCount`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationstepsplan/#stepcount)

***

### steps

[Section titled “steps”](#steps)

> **steps**: readonly [`GameboardScenarioSimulationCommandStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationcommandstep/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:668](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L668)

Generated command steps.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardPatrolSimulationStepsPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationstepsplan/).[`steps`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationstepsplan/#steps)

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:670](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L670)

Plan-level warnings.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardPatrolSimulationStepsPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationstepsplan/).[`warnings`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationstepsplan/#warnings)

# GameboardPatrolSimulationStepsPlan

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:662](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L662)

Generated simulation command steps plus assignment diagnostics.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`GameboardPatrolSimulationScriptPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationscriptplan/)

## Properties

[Section titled “Properties”](#properties)

### assignments

[Section titled “assignments”](#assignments)

> **assignments**: readonly [`GameboardPatrolSimulationAssignmentPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsimulationassignmentplan/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:666](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L666)

Assignment diagnostics.

***

### errors

[Section titled “errors”](#errors)

> **errors**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:672](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L672)

Plan-level errors.

***

### stepCount

[Section titled “stepCount”](#stepcount)

> **stepCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:664](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L664)

Total generated step count.

***

### steps

[Section titled “steps”](#steps)

> **steps**: readonly [`GameboardScenarioSimulationCommandStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationcommandstep/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:668](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L668)

Generated command steps.

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:670](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L670)

Plan-level warnings.

# GameboardPatrolSnapshot

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:85](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L85)

Joined runtime snapshot for a patrol agent.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)

## Properties

[Section titled “Properties”](#properties)

### actor?

[Section titled “actor?”](#actor)

> `optional` **actor?**: [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:91](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L91)

Actor snapshot when the patrol placement is registered as an actor.

***

### agent

[Section titled “agent”](#agent)

> **agent**: `object`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:93](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L93)

Patrol agent trait value.

#### active

[Section titled “active”](#active)

> **active**: `boolean` = `true`

Whether the patrol agent is active.

#### currentWaypointIndex

[Section titled “currentWaypointIndex”](#currentwaypointindex)

> **currentWaypointIndex**: `number` = `0`

Current waypoint index.

#### loop

[Section titled “loop”](#loop)

> **loop**: `boolean` = `true`

Whether the route loops back to the first waypoint.

#### pauseTicks

[Section titled “pauseTicks”](#pauseticks)

> **pauseTicks**: `number` = `0`

Ticks to wait after reaching each waypoint.

#### roundsCompleted

[Section titled “roundsCompleted”](#roundscompleted)

> **roundsCompleted**: `number` = `0`

Number of completed route rounds.

#### routeId

[Section titled “routeId”](#routeid)

> **routeId**: `string` = `''`

Route id followed by this patrol.

#### segmentCosts

[Section titled “segmentCosts”](#segmentcosts)

> **segmentCosts**: `number`\[]

Optional movement budget per route segment.

#### targetWaypointIndex

[Section titled “targetWaypointIndex”](#targetwaypointindex)

> **targetWaypointIndex**: `number` = `-1`

Target waypoint index for an in-flight segment.

#### waitTicksRemaining

[Section titled “waitTicksRemaining”](#waitticksremaining)

> **waitTicksRemaining**: `number` = `0`

Remaining wait ticks before the next segment.

#### waypointKeys

[Section titled “waypointKeys”](#waypointkeys)

> **waypointKeys**: `string`\[]

Ordered route waypoint tile keys.

***

### entity

[Section titled “entity”](#entity)

> **entity**: `Entity`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:87](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L87)

Live Koota entity.

***

### placement

[Section titled “placement”](#placement)

> **placement**: `object`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:89](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L89)

Placement state associated with the patrol.

#### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string` = `''`

Manifest or external registry asset id.

#### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Axial coordinates of the origin tile.

#### elevation

[Section titled “elevation”](#elevation)

> **elevation**: `number` = `0`

Base tile elevation where the placement was spawned.

#### elevationOffset

[Section titled “elevationOffset”](#elevationoffset)

> **elevationOffset**: `number` = `0`

Extra vertical offset above the tile elevation.

#### id

[Section titled “id”](#id)

> **id**: `string` = `''`

Stable placement id.

#### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Gameplay category for rules, selectors, and rendering.

#### layer

[Section titled “layer”](#layer)

> **layer**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Render and occupancy layer.

#### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Record`<`string`, `string` | `number` | `boolean` | `null`>

Serializable placement metadata for rules, ECS interop, and render hints.

#### order

[Section titled “order”](#order)

> **order**: `number` = `0`

Stable sort order used by renderers and snapshots.

#### position

[Section titled “position”](#position)

> **position**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

World-space placement anchor after elevation and local offsets.

#### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean` = `false`

Whether the placement depends on local-only EXTRA assets.

#### rotationRadians

[Section titled “rotationRadians”](#rotationradians)

> **rotationRadians**: `number` = `0`

Rotation in radians derived from `rotationSteps`.

#### rotationSteps

[Section titled “rotationSteps”](#rotationsteps)

> **rotationSteps**: `number` = `0`

Clockwise 60-degree rotation steps.

#### scale

[Section titled “scale”](#scale)

> **scale**: `number` = `1`

Uniform render scale.

#### stackIndex

[Section titled “stackIndex”](#stackindex)

> **stackIndex**: `number` | `undefined`

Optional stack index for layered terrain and vertical props.

#### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

KayKit texture set applied to this placement.

#### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string` = `''`

Origin tile key in `q,r` form.

***

### state

[Section titled “state”](#state)

> **state**: `object`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:95](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L95)

Patrol state trait value.

#### lastPathKeys

[Section titled “lastPathKeys”](#lastpathkeys)

> **lastPathKeys**: `string`\[]

Last requested movement path tile keys.

#### reason

[Section titled “reason”](#reason)

> **reason**: `string` | `undefined`

Blocked or paused reason.

#### status

[Section titled “status”](#status)

> **status**: [`GameboardPatrolStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardpatrolstatus/)

Current patrol status.

#### targetKey

[Section titled “targetKey”](#targetkey)

> **targetKey**: `string` = `''`

Current target waypoint tile key.

# GameboardPatrolWaitingEvent

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:111](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L111)

Patrol agent entered or remained in a waiting state.

## Properties

[Section titled “Properties”](#properties)

### patrol

[Section titled “patrol”](#patrol)

> **patrol**: [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:115](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L115)

Patrol advancement result.

***

### type

[Section titled “type”](#type)

> **type**: `"patrol-waiting"`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:113](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L113)

Event discriminator.

# GameboardPatrolWaypointRecord

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:219](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L219)

Interop record for one patrol waypoint.

## Properties

[Section titled “Properties”](#properties)

### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:227](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L227)

Waypoint tile coordinates.

***

### index

[Section titled “index”](#index)

> **index**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:229](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L229)

Waypoint index in route order.

***

### routeId

[Section titled “routeId”](#routeid)

> **routeId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:221](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L221)

Patrol route id.

***

### source

[Section titled “source”](#source)

> **source**: `GameboardPatrolWaypointSource`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:231](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L231)

Source used to create the waypoint.

***

### spawnGroupId?

[Section titled “spawnGroupId?”](#spawngroupid)

> `optional` **spawnGroupId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:233](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L233)

Spawn group id when sourced from a group.

***

### spawnLocationIndex?

[Section titled “spawnLocationIndex?”](#spawnlocationindex)

> `optional` **spawnLocationIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:235](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L235)

Spawn location index when sourced from a group.

***

### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:225](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L225)

Waypoint tile key.

***

### waypointId

[Section titled “waypointId”](#waypointid)

> **waypointId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:223](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L223)

Waypoint entity id.

# GameboardPieceCollectionLayoutRuleOptions

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:273](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L273)

Overrides used when turning a compatible piece collection into one fill rule.

## Extends

[Section titled “Extends”](#extends)

* `Omit`<[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/), `"assetId"`>

## Properties

[Section titled “Properties”](#properties)

### archetypes?

[Section titled “archetypes?”](#archetypes)

> `optional` **archetypes?**: `Readonly`<`Record`<`string`, [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:261](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L261)

Archetype registry used by layout.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`archetypes`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#archetypes)

***

### count?

[Section titled “count?”](#count)

> `optional` **count?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:243](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L243)

Explicit placement count.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`count`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#count)

***

### criteria?

[Section titled “criteria?”](#criteria)

> `optional` **criteria?**: [`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:253](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L253)

Criteria merged over piece defaults.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`criteria`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#criteria)

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:259](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L259)

Vertical offset override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`elevationOffset`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#elevationoffset)

***

### fill?

[Section titled “fill?”](#fill)

> `optional` **fill?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:245](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L245)

Fraction of candidate sites to fill.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`fill`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#fill)

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:239](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L239)

Fill rule id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`id`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#id)

***

### idPrefix?

[Section titled “idPrefix?”](#idprefix)

> `optional` **idPrefix?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:251](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L251)

Prefix used for generated placement ids.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`idPrefix`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#idprefix)

***

### maxCount?

[Section titled “maxCount?”](#maxcount)

> `optional` **maxCount?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:249](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L249)

Maximum placement count.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`maxCount`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#maxcount)

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:267](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L267)

Metadata merged over piece metadata.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`metadata`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#metadata)

***

### minCount?

[Section titled “minCount?”](#mincount)

> `optional` **minCount?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:247](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L247)

Minimum placement count.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`minCount`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#mincount)

***

### occupancyGuard?

[Section titled “occupancyGuard?”](#occupancyguard)

> `optional` **occupancyGuard?**: [`GameboardPlacementOccupancyGuard`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementoccupancyguard/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:265](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L265)

Optional occupancy guard for spawned placements.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`occupancyGuard`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#occupancyguard)

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:263](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L263)

Local-only asset override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`requiresExtra`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#requiresextra)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number` | `"random"`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:257](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L257)

Rotation override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:255](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L255)

Uniform render scale override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#scale)

# GameboardPieceCompatibilityBatchOptions

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:85](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L85)

Batch options for declaring pieces from compatibility reports.

## Extends

[Section titled “Extends”](#extends)

* `Omit`<[`GameboardPieceCompatibilityDeclarationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiececompatibilitydeclarationoptions/), `"id"` | `"assetId"`>

## Properties

[Section titled “Properties”](#properties)

### archetype?

[Section titled “archetype?”](#archetype)

> `optional` **archetype?**: [`GameboardLayoutArchetypeInput`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetypeinput/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:51](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L51)

Layout archetype id or inline archetype.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`archetype`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#archetype)

***

### assetIdPrefix?

[Section titled “assetIdPrefix?”](#assetidprefix)

> `optional` **assetIdPrefix?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:90](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L90)

Prefix added to generated asset ids.

***

### criteria?

[Section titled “criteria?”](#criteria)

> `optional` **criteria?**: [`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:59](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L59)

Layout criteria for selecting valid sites.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`criteria`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#criteria)

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L65)

Vertical offset above the tile elevation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`elevationOffset`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#elevationoffset)

***

### footprint?

[Section titled “footprint?”](#footprint)

> `optional` **footprint?**: [`GameboardLayoutFootprintInput`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutfootprintinput/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:57](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L57)

Placement footprint.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`footprint`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#footprint)

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:53](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L53)

Placement kind override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`kind`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#kind)

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L45)

Human-readable label. Defaults from `id`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`label`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#label)

***

### layer?

[Section titled “layer?”](#layer)

> `optional` **layer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:55](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L55)

Placement layer override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`layer`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#layer)

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:71](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L71)

Serializable metadata merged into generated placements.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`metadata`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#metadata)

***

### overrides?

[Section titled “overrides?”](#overrides)

> `optional` **overrides?**: `Readonly`<`Record`<`string`, [`GameboardPieceCompatibilityDeclarationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiececompatibilitydeclarationoptions/)>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:92](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L92)

Per-report declaration overrides keyed by report id.

***

### pieceIdPrefix?

[Section titled “pieceIdPrefix?”](#pieceidprefix)

> `optional` **pieceIdPrefix?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L88)

Prefix added to generated piece ids.

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L67)

Whether the asset is local-only or EXTRA.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`requiresExtra`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#requiresextra)

***

### role?

[Section titled “role?”](#role)

> `optional` **role?**: [`GameboardPieceRole`](/declarative-hex-worlds/reference/index/type-aliases/gameboardpiecerole/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:49](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L49)

Placement role. Defaults from id heuristics.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`role`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#role)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number` | `"random"`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:63](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L63)

Clockwise 60-degree rotation steps or random rotation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:61](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L61)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#scale)

***

### source?

[Section titled “source?”](#source)

> `optional` **source?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L47)

Source pack or registry name.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`source`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#source)

***

### tags?

[Section titled “tags?”](#tags)

> `optional` **tags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:69](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L69)

Piece tags used by registry selection.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`tags`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#tags)

# GameboardPieceCompatibilityDeclarationOptions

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:77](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L77)

Overrides applied while declaring one piece from compatibility analysis.

## Extends

[Section titled “Extends”](#extends)

* `Omit`<[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/), `"id"`>

## Properties

[Section titled “Properties”](#properties)

### archetype?

[Section titled “archetype?”](#archetype)

> `optional` **archetype?**: [`GameboardLayoutArchetypeInput`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetypeinput/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:51](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L51)

Layout archetype id or inline archetype.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`archetype`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#archetype)

***

### assetId?

[Section titled “assetId?”](#assetid)

> `optional` **assetId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:43](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L43)

Render asset id. Defaults to `id`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`assetId`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#assetid)

***

### criteria?

[Section titled “criteria?”](#criteria)

> `optional` **criteria?**: [`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:59](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L59)

Layout criteria for selecting valid sites.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`criteria`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#criteria)

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L65)

Vertical offset above the tile elevation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`elevationOffset`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#elevationoffset)

***

### footprint?

[Section titled “footprint?”](#footprint)

> `optional` **footprint?**: [`GameboardLayoutFootprintInput`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutfootprintinput/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:57](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L57)

Placement footprint.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`footprint`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#footprint)

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:79](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L79)

Override piece id. Defaults to the compatibility report id.

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:53](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L53)

Placement kind override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`kind`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#kind)

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L45)

Human-readable label. Defaults from `id`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`label`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#label)

***

### layer?

[Section titled “layer?”](#layer)

> `optional` **layer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:55](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L55)

Placement layer override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`layer`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#layer)

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:71](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L71)

Serializable metadata merged into generated placements.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`metadata`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#metadata)

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L67)

Whether the asset is local-only or EXTRA.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`requiresExtra`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#requiresextra)

***

### role?

[Section titled “role?”](#role)

> `optional` **role?**: [`GameboardPieceRole`](/declarative-hex-worlds/reference/index/type-aliases/gameboardpiecerole/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:49](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L49)

Placement role. Defaults from id heuristics.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`role`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#role)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number` | `"random"`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:63](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L63)

Clockwise 60-degree rotation steps or random rotation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:61](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L61)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#scale)

***

### source?

[Section titled “source?”](#source)

> `optional` **source?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L47)

Source pack or registry name.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`source`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#source)

***

### tags?

[Section titled “tags?”](#tags)

> `optional` **tags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:69](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L69)

Piece tags used by registry selection.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-14)

[`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/).[`tags`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/#tags)

# GameboardPieceDeclaration

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:98](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L98)

Normalized reusable gameboard piece declaration.

## Properties

[Section titled “Properties”](#properties)

### archetype

[Section titled “archetype”](#archetype)

> **archetype**: [`GameboardLayoutArchetypeInput`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetypeinput/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:110](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L110)

Layout archetype id or inline archetype.

***

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:102](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L102)

Render asset id.

***

### criteria

[Section titled “criteria”](#criteria)

> **criteria**: [`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:118](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L118)

Layout criteria for selecting valid sites.

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:124](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L124)

Vertical offset above the tile elevation.

***

### footprint?

[Section titled “footprint?”](#footprint)

> `optional` **footprint?**: [`GameboardLayoutFootprintInput`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutfootprintinput/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:116](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L116)

Placement footprint.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:100](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L100)

Stable piece id.

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:112](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L112)

Placement kind override.

***

### label

[Section titled “label”](#label)

> **label**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:104](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L104)

Human-readable label.

***

### layer?

[Section titled “layer?”](#layer)

> `optional` **layer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:114](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L114)

Placement layer override.

***

### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L130)

Serializable metadata merged into generated placements.

***

### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L126)

Whether the asset is local-only or EXTRA.

***

### role

[Section titled “role”](#role)

> **role**: [`GameboardPieceRole`](/declarative-hex-worlds/reference/index/type-aliases/gameboardpiecerole/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:108](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L108)

Placement role.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number` | `"random"`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:122](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L122)

Clockwise 60-degree rotation steps or random rotation.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:120](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L120)

Uniform render scale.

***

### source

[Section titled “source”](#source)

> **source**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:106](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L106)

Source pack or registry name.

***

### tags

[Section titled “tags”](#tags)

> **tags**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L128)

Piece tags used by registry selection.

# GameboardPieceDeclarationInput

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:39](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L39)

Input for declaring a reusable gameboard piece from any asset pack.

## Properties

[Section titled “Properties”](#properties)

### archetype?

[Section titled “archetype?”](#archetype)

> `optional` **archetype?**: [`GameboardLayoutArchetypeInput`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetypeinput/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:51](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L51)

Layout archetype id or inline archetype.

***

### assetId?

[Section titled “assetId?”](#assetid)

> `optional` **assetId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:43](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L43)

Render asset id. Defaults to `id`.

***

### criteria?

[Section titled “criteria?”](#criteria)

> `optional` **criteria?**: [`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:59](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L59)

Layout criteria for selecting valid sites.

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L65)

Vertical offset above the tile elevation.

***

### footprint?

[Section titled “footprint?”](#footprint)

> `optional` **footprint?**: [`GameboardLayoutFootprintInput`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutfootprintinput/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:57](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L57)

Placement footprint.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:41](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L41)

Stable piece id.

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:53](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L53)

Placement kind override.

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L45)

Human-readable label. Defaults from `id`.

***

### layer?

[Section titled “layer?”](#layer)

> `optional` **layer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:55](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L55)

Placement layer override.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:71](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L71)

Serializable metadata merged into generated placements.

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L67)

Whether the asset is local-only or EXTRA.

***

### role?

[Section titled “role?”](#role)

> `optional` **role?**: [`GameboardPieceRole`](/declarative-hex-worlds/reference/index/type-aliases/gameboardpiecerole/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:49](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L49)

Placement role. Defaults from id heuristics.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number` | `"random"`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:63](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L63)

Clockwise 60-degree rotation steps or random rotation.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:61](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L61)

Uniform render scale.

***

### source?

[Section titled “source?”](#source)

> `optional` **source?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L47)

Source pack or registry name.

***

### tags?

[Section titled “tags?”](#tags)

> `optional` **tags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:69](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L69)

Piece tags used by registry selection.

# GameboardPieceLayoutRuleOptions

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:237](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L237)

Overrides used when turning a piece into a layout fill rule.

## Properties

[Section titled “Properties”](#properties)

### archetypes?

[Section titled “archetypes?”](#archetypes)

> `optional` **archetypes?**: `Readonly`<`Record`<`string`, [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:261](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L261)

Archetype registry used by layout.

***

### assetId?

[Section titled “assetId?”](#assetid)

> `optional` **assetId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:241](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L241)

Asset id override.

***

### count?

[Section titled “count?”](#count)

> `optional` **count?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:243](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L243)

Explicit placement count.

***

### criteria?

[Section titled “criteria?”](#criteria)

> `optional` **criteria?**: [`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:253](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L253)

Criteria merged over piece defaults.

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:259](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L259)

Vertical offset override.

***

### fill?

[Section titled “fill?”](#fill)

> `optional` **fill?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:245](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L245)

Fraction of candidate sites to fill.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:239](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L239)

Fill rule id.

***

### idPrefix?

[Section titled “idPrefix?”](#idprefix)

> `optional` **idPrefix?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:251](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L251)

Prefix used for generated placement ids.

***

### maxCount?

[Section titled “maxCount?”](#maxcount)

> `optional` **maxCount?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:249](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L249)

Maximum placement count.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:267](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L267)

Metadata merged over piece metadata.

***

### minCount?

[Section titled “minCount?”](#mincount)

> `optional` **minCount?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:247](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L247)

Minimum placement count.

***

### occupancyGuard?

[Section titled “occupancyGuard?”](#occupancyguard)

> `optional` **occupancyGuard?**: [`GameboardPlacementOccupancyGuard`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementoccupancyguard/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:265](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L265)

Optional occupancy guard for spawned placements.

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:263](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L263)

Local-only asset override.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number` | `"random"`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:257](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L257)

Rotation override.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:255](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L255)

Uniform render scale override.

# GameboardPiecePlacementInspection

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:313](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L313)

Placement inspection report for one piece.

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:317](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L317)

Asset id used by generated placements.

***

### layoutOptions

[Section titled “layoutOptions”](#layoutoptions)

> **layoutOptions**: [`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:323](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L323)

Layout options derived from the piece.

***

### pieceId

[Section titled “pieceId”](#pieceid)

> **pieceId**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:315](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L315)

Piece id inspected.

***

### placements

[Section titled “placements”](#placements)

> **placements**: readonly [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:327](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L327)

Generated placement options.

***

### role

[Section titled “role”](#role)

> **role**: [`GameboardPieceRole`](/declarative-hex-worlds/reference/index/type-aliases/gameboardpiecerole/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:319](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L319)

Piece role.

***

### siteInspection

[Section titled “siteInspection”](#siteinspection)

> **siteInspection**: [`GameboardLayoutSiteInspection`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutsiteinspection/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:325](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L325)

Site inspection used for placement.

***

### source

[Section titled “source”](#source)

> **source**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:321](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L321)

Piece source.

# GameboardPiecePlacementOptions

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:290](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L290)

Options for creating direct placement options from a piece.

## Extends

[Section titled “Extends”](#extends)

* `Omit`<[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/), `"fill"` | `"minCount"` | `"maxCount"`>

## Properties

[Section titled “Properties”](#properties)

### archetypes?

[Section titled “archetypes?”](#archetypes)

> `optional` **archetypes?**: `Readonly`<`Record`<`string`, [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:295](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L295)

Archetype registry used by layout.

#### Overrides

[Section titled “Overrides”](#overrides)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`archetypes`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#archetypes)

***

### assetId?

[Section titled “assetId?”](#assetid)

> `optional` **assetId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:241](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L241)

Asset id override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`assetId`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#assetid)

***

### count?

[Section titled “count?”](#count)

> `optional` **count?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:243](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L243)

Explicit placement count.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`count`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#count)

***

### criteria?

[Section titled “criteria?”](#criteria)

> `optional` **criteria?**: [`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:253](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L253)

Criteria merged over piece defaults.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`criteria`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#criteria)

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:259](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L259)

Vertical offset override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`elevationOffset`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#elevationoffset)

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:239](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L239)

Fill rule id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`id`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#id)

***

### idPrefix?

[Section titled “idPrefix?”](#idprefix)

> `optional` **idPrefix?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:251](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L251)

Prefix used for generated placement ids.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`idPrefix`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#idprefix)

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:267](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L267)

Metadata merged over piece metadata.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`metadata`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#metadata)

***

### occupancyGuard?

[Section titled “occupancyGuard?”](#occupancyguard)

> `optional` **occupancyGuard?**: [`GameboardPlacementOccupancyGuard`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementoccupancyguard/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:265](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L265)

Optional occupancy guard for spawned placements.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`occupancyGuard`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#occupancyguard)

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:263](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L263)

Local-only asset override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`requiresExtra`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#requiresextra)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number` | `"random"`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:257](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L257)

Rotation override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:255](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L255)

Uniform render scale override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#scale)

***

### seed?

[Section titled “seed?”](#seed)

> `optional` **seed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:293](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L293)

Seed used for site selection.

# GameboardPieceRegistry

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L136)

Piece registry with lookup indexes and declaration warnings.

## Properties

[Section titled “Properties”](#properties)

### byAssetId

[Section titled “byAssetId”](#byassetid)

> **byAssetId**: `Readonly`<`Record`<`string`, [`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:142](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L142)

Pieces keyed by asset id.

***

### byId

[Section titled “byId”](#byid)

> **byId**: `Readonly`<`Record`<`string`, [`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:140](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L140)

Pieces keyed by piece id.

***

### pieces

[Section titled “pieces”](#pieces)

> **pieces**: readonly [`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:138](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L138)

Normalized piece declarations.

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:144](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L144)

Non-fatal registry construction warnings.

# GameboardPieceRegistryAnalysis

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:215](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L215)

Summary and diagnostics for a piece registry.

## Properties

[Section titled “Properties”](#properties)

### checks

[Section titled “checks”](#checks)

> **checks**: readonly [`GameboardPieceRegistryAnalysisCheck`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryanalysischeck/)\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:231](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L231)

Per-check analysis results.

***

### errors

[Section titled “errors”](#errors)

> **errors**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:229](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L229)

Fatal analysis diagnostics.

***

### localOnlyCount

[Section titled “localOnlyCount”](#localonlycount)

> **localOnlyCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:219](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L219)

Number of pieces that require local-only assets.

***

### pieceCount

[Section titled “pieceCount”](#piececount)

> **pieceCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:217](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L217)

Number of pieces in the registry.

***

### roleCounts

[Section titled “roleCounts”](#rolecounts)

> **roleCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:221](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L221)

Piece counts by role.

***

### sourceCounts

[Section titled “sourceCounts”](#sourcecounts)

> **sourceCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:223](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L223)

Piece counts by source.

***

### tagCounts

[Section titled “tagCounts”](#tagcounts)

> **tagCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:225](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L225)

Piece counts by tag.

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:227](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L227)

Non-fatal analysis diagnostics.

# GameboardPieceRegistryAnalysisCheck

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:187](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L187)

Result for one registry analysis check.

## Properties

[Section titled “Properties”](#properties)

### errors

[Section titled “errors”](#errors)

> **errors**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:201](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L201)

Fatal check diagnostics.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:189](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L189)

Check id.

***

### mode

[Section titled “mode”](#mode)

> **mode**: [`GameboardPieceRegistryAnalysisCheckMode`](/declarative-hex-worlds/reference/index/type-aliases/gameboardpieceregistryanalysischeckmode/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:191](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L191)

Check mode.

***

### selectedCount

[Section titled “selectedCount”](#selectedcount)

> **selectedCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:195](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L195)

Number of selected pieces.

***

### selectedIds

[Section titled “selectedIds”](#selectedids)

> **selectedIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:197](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L197)

Selected piece ids.

***

### selection

[Section titled “selection”](#selection)

> **selection**: [`GameboardPieceRegistrySelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryselection/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:193](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L193)

Selection used by the check.

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:199](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L199)

Non-fatal check diagnostics.

# GameboardPieceRegistryAnalysisCheckInput

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:175](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L175)

Input for one registry analysis check.

## Properties

[Section titled “Properties”](#properties)

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:177](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L177)

Check id used in diagnostics.

***

### mode?

[Section titled “mode?”](#mode)

> `optional` **mode?**: [`GameboardPieceRegistryAnalysisCheckMode`](/declarative-hex-worlds/reference/index/type-aliases/gameboardpieceregistryanalysischeckmode/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:179](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L179)

Check mode.

***

### selection?

[Section titled “selection?”](#selection)

> `optional` **selection?**: [`GameboardPieceRegistrySelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryselection/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:181](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L181)

Piece selection to analyze.

# GameboardPieceRegistryFillRulesOptions

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:279](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L279)

Options for creating fill rules from all pieces selected from a registry.

## Extends

[Section titled “Extends”](#extends)

* `Omit`<[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/), `"id"` | `"assetId"`>

## Properties

[Section titled “Properties”](#properties)

### archetypes?

[Section titled “archetypes?”](#archetypes)

> `optional` **archetypes?**: `Readonly`<`Record`<`string`, [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:261](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L261)

Archetype registry used by layout.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`archetypes`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#archetypes)

***

### count?

[Section titled “count?”](#count)

> `optional` **count?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:243](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L243)

Explicit placement count.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`count`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#count)

***

### criteria?

[Section titled “criteria?”](#criteria)

> `optional` **criteria?**: [`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:253](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L253)

Criteria merged over piece defaults.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`criteria`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#criteria)

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:259](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L259)

Vertical offset override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`elevationOffset`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#elevationoffset)

***

### fill?

[Section titled “fill?”](#fill)

> `optional` **fill?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:245](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L245)

Fraction of candidate sites to fill.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`fill`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#fill)

***

### idPrefix?

[Section titled “idPrefix?”](#idprefix)

> `optional` **idPrefix?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:251](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L251)

Prefix used for generated placement ids.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`idPrefix`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#idprefix)

***

### maxCount?

[Section titled “maxCount?”](#maxcount)

> `optional` **maxCount?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:249](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L249)

Maximum placement count.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`maxCount`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#maxcount)

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:267](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L267)

Metadata merged over piece metadata.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`metadata`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#metadata)

***

### minCount?

[Section titled “minCount?”](#mincount)

> `optional` **minCount?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:247](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L247)

Minimum placement count.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`minCount`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#mincount)

***

### occupancyGuard?

[Section titled “occupancyGuard?”](#occupancyguard)

> `optional` **occupancyGuard?**: [`GameboardPlacementOccupancyGuard`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementoccupancyguard/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:265](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L265)

Optional occupancy guard for spawned placements.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`occupancyGuard`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#occupancyguard)

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:263](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L263)

Local-only asset override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`requiresExtra`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#requiresextra)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number` | `"random"`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:257](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L257)

Rotation override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#rotationsteps)

***

### ruleIdPrefix?

[Section titled “ruleIdPrefix?”](#ruleidprefix)

> `optional` **ruleIdPrefix?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:284](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L284)

Prefix applied to generated rule ids.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:255](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L255)

Uniform render scale override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#scale)

***

### selection?

[Section titled “selection?”](#selection)

> `optional` **selection?**: [`GameboardPieceRegistrySelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryselection/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:282](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L282)

Selection used to choose registry pieces.

# GameboardPieceRegistrySelection

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:155](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L155)

Piece selection filter used by registry helpers.

## Properties

[Section titled “Properties”](#properties)

### assetIds?

[Section titled “assetIds?”](#assetids)

> `optional` **assetIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:159](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L159)

Asset ids to include.

***

### excludeTags?

[Section titled “excludeTags?”](#excludetags)

> `optional` **excludeTags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:167](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L167)

Tags that must all be absent.

***

### ids?

[Section titled “ids?”](#ids)

> `optional` **ids?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:157](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L157)

Piece ids to include.

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:169](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L169)

Filter by local-only or EXTRA requirement.

***

### roles?

[Section titled “roles?”](#roles)

> `optional` **roles?**: readonly [`GameboardPieceRole`](/declarative-hex-worlds/reference/index/type-aliases/gameboardpiecerole/)\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:161](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L161)

Piece roles to include.

***

### sources?

[Section titled “sources?”](#sources)

> `optional` **sources?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:163](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L163)

Source names to include.

***

### tags?

[Section titled “tags?”](#tags)

> `optional` **tags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:165](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L165)

Tags that must all be present.

# GameboardPieceSourceUrlOptions

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:301](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L301)

Options for resolving piece source URLs.

## Properties

[Section titled “Properties”](#properties)

### encode?

[Section titled “encode?”](#encode)

> `optional` **encode?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:307](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L307)

Encode path components when joining URLs.

***

### sourceRoot?

[Section titled “sourceRoot?”](#sourceroot)

> `optional` **sourceRoot?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:303](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L303)

Default root URL or path for source-relative assets.

***

### sourceRoots?

[Section titled “sourceRoots?”](#sourceroots)

> `optional` **sourceRoots?**: `Readonly`<`Record`<`string`, `string`>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:305](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L305)

Root URL or path by piece source.

# GameboardPlacementAnimationUrlOptions

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:43](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L43)

URL resolution inputs for external animation clips.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/)

## Properties

[Section titled “Properties”](#properties)

### animationUrlResolver?

[Section titled “animationUrlResolver?”](#animationurlresolver)

> `optional` **animationUrlResolver?**: (`placement`) => `string` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L47)

App-specific animation URL resolver.

#### Parameters

[Section titled “Parameters”](#parameters)

##### placement

[Section titled “placement”](#placement)

[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

#### Returns

[Section titled “Returns”](#returns)

`string` | `undefined`

***

### animationUrls?

[Section titled “animationUrls?”](#animationurls)

> `optional` **animationUrls?**: `Readonly`<`Record`<`string`, `string`>>

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L45)

Explicit asset-id-to-animation-URL map.

# GameboardPlacementAssetUrlOptions

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:28](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L28)

URL resolution inputs for gameboard placement models.

## Extends

[Section titled “Extends”](#extends)

* [`ManifestAssetUrlOptions`](/declarative-hex-worlds/reference/manifest/schema/interfaces/manifestasseturloptions/)

## Extended by

[Section titled “Extended by”](#extended-by)

* [`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/)

## Properties

[Section titled “Properties”](#properties)

### assetUrls?

[Section titled “assetUrls?”](#asseturls)

> `optional` **assetUrls?**: `Readonly`<`Record`<`string`, `string`>>

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:32](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L32)

Explicit asset-id-to-URL overrides, useful for local-only Vite `@fs` assets.

***

### baseUrl?

[Section titled “baseUrl?”](#baseurl)

> `optional` **baseUrl?**: `string` | `URL`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:147](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L147)

Base URL applied to every model path when no edition-specific base exists.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`ManifestAssetUrlOptions`](/declarative-hex-worlds/reference/manifest/schema/interfaces/manifestasseturloptions/).[`baseUrl`](/declarative-hex-worlds/reference/manifest/schema/interfaces/manifestasseturloptions/#baseurl)

***

### bootstrapAssetRoot?

[Section titled “bootstrapAssetRoot?”](#bootstrapassetroot)

> `optional` **bootstrapAssetRoot?**: `string` | `URL`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:160](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L160)

Consumer’s bootstrap asset root (per PRD RB3).

When set, manifest `sourcePath` values (e.g. `buildings/blue/foo.gltf`) are joined with this root to produce the resolved URL — `<bootstrapAssetRoot>/<sourcePath>` (flat layout, no subdirectory prefix).

Honored only when neither [baseUrl](/declarative-hex-worlds/reference/manifest/schema/interfaces/manifestasseturloptions/#baseurl) nor a matching [editionBaseUrls](/declarative-hex-worlds/reference/manifest/schema/interfaces/manifestasseturloptions/#editionbaseurls) entry is set; explicit base URLs always win.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`ManifestAssetUrlOptions`](/declarative-hex-worlds/reference/manifest/schema/interfaces/manifestasseturloptions/).[`bootstrapAssetRoot`](/declarative-hex-worlds/reference/manifest/schema/interfaces/manifestasseturloptions/#bootstrapassetroot)

***

### catalog?

[Section titled “catalog?”](#catalog)

> `optional` **catalog?**: [`ManifestAssetCatalog`](/declarative-hex-worlds/reference/manifest/schema/type-aliases/manifestassetcatalog/)

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:30](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L30)

Manifest or manifest bundle used for packaged FREE/EXTRA asset ids.

***

### editionBaseUrls?

[Section titled “editionBaseUrls?”](#editionbaseurls)

> `optional` **editionBaseUrls?**: `Partial`<`Record`<`"free"` | `"extra"`, `string` | `URL`>>

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:149](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L149)

Per-edition base URLs, useful when FREE is packaged and EXTRA is local.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`ManifestAssetUrlOptions`](/declarative-hex-worlds/reference/manifest/schema/interfaces/manifestasseturloptions/).[`editionBaseUrls`](/declarative-hex-worlds/reference/manifest/schema/interfaces/manifestasseturloptions/#editionbaseurls)

***

### fallback?

[Section titled “fallback?”](#fallback)

> `optional` **fallback?**: (`placement`) => `string` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:34](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L34)

Last-chance resolver for app-specific asset stores.

#### Parameters

[Section titled “Parameters”](#parameters)

##### placement

[Section titled “placement”](#placement)

[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

#### Returns

[Section titled “Returns”](#returns)

`string` | `undefined`

# GameboardPlacementOccupancyGuardOptions

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:247](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L247)

Options used by spawn, update, and move helpers to enforce occupancy.

## Properties

[Section titled “Properties”](#properties)

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:249](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L249)

Placement ids ignored when checking blockers, usually the moving entity.

***

### requireUnblocked?

[Section titled “requireUnblocked?”](#requireunblocked)

> `optional` **requireUnblocked?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:251](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L251)

Require no blockers even if the placement itself is non-blocking.

# GameboardPlacementOccupancyInspection

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:223](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L223)

Detailed result from an occupancy inspection.

## Properties

[Section titled “Properties”](#properties)

### blockers

[Section titled “blockers”](#blockers)

> **blockers**: readonly [`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:237](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L237)

Blocking occupancy records found in the footprint.

***

### blocksMovement

[Section titled “blocksMovement”](#blocksmovement)

> **blocksMovement**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:233](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L233)

Whether the proposed placement blocks movement.

***

### canOccupy

[Section titled “canOccupy”](#canoccupy)

> **canOccupy**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:239](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L239)

Whether the placement can occupy the inspected footprint.

***

### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:227](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L227)

Axial coordinates for the origin tile.

***

### footprintTileKeys

[Section titled “footprintTileKeys”](#footprinttilekeys)

> **footprintTileKeys**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:229](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L229)

Tile keys in the proposed placement footprint.

***

### missingTileKeys

[Section titled “missingTileKeys”](#missingtilekeys)

> **missingTileKeys**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:231](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L231)

Footprint tile keys not present in the world.

***

### occupancyGroup

[Section titled “occupancyGroup”](#occupancygroup)

> **occupancyGroup**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:235](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L235)

Occupancy group assigned to the proposed placement.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:241](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L241)

Machine-readable reason when `canOccupy` is false.

***

### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:225](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L225)

Origin tile key that was inspected.

# GameboardPlacementOccupancyRecord

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:120](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L120)

Relation payload connecting a placement to every occupied footprint tile.

## Properties

[Section titled “Properties”](#properties)

### blocksMovement

[Section titled “blocksMovement”](#blocksmovement)

> **blocksMovement**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:132](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L132)

Whether this occupancy blocks movement.

***

### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L126)

Occupied tile coordinates.

***

### footprintIndex

[Section titled “footprintIndex”](#footprintindex)

> **footprintIndex**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L130)

Zero-based footprint index.

***

### occupancyGroup

[Section titled “occupancyGroup”](#occupancygroup)

> **occupancyGroup**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L134)

Occupancy group used to allow compatible colocation.

***

### originTileKey

[Section titled “originTileKey”](#origintilekey)

> **originTileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L128)

Origin tile key for the placement.

***

### placementId

[Section titled “placementId”](#placementid)

> **placementId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:122](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L122)

Placement id.

***

### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:124](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L124)

Occupied tile key.

# GameboardPlacementPositionOffset

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:284](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L284)

Optional local offset applied to a placement after tile/elevation anchoring.

## Properties

[Section titled “Properties”](#properties)

### x?

[Section titled “x?”](#x)

> `optional` **x?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:286](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L286)

X-axis world offset.

***

### y?

[Section titled “y?”](#y)

> `optional` **y?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:288](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L288)

Y-axis world offset.

***

### z?

[Section titled “z?”](#z)

> `optional` **z?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:290](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L290)

Z-axis world offset.

# GameboardPlacementSpec

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:163](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L163)

Serializable placement state in a generated gameboard plan.

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:173](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L173)

Manifest or external registry asset id.

***

### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:169](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L169)

Origin tile coordinates.

***

### elevation

[Section titled “elevation”](#elevation)

> **elevation**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:181](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L181)

Origin tile elevation.

***

### elevationOffset

[Section titled “elevationOffset”](#elevationoffset)

> **elevationOffset**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:183](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L183)

Vertical offset above the origin tile.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:165](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L165)

Stable placement id.

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:175](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L175)

Placement category.

***

### layer

[Section titled “layer”](#layer)

> **layer**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:177](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L177)

Render and gameplay layer.

***

### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:197](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L197)

Serializable metadata for gameplay, layout, and renderer hints.

***

### order

[Section titled “order”](#order)

> **order**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:191](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L191)

Stable render and snapshot sort order.

***

### position

[Section titled “position”](#position)

> **position**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:171](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L171)

World position after tile elevation and placement offset.

***

### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:195](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L195)

Whether this placement requires local-only EXTRA assets.

***

### rotationRadians

[Section titled “rotationRadians”](#rotationradians)

> **rotationRadians**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:187](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L187)

Rotation in radians derived from `rotationSteps`.

***

### rotationSteps

[Section titled “rotationSteps”](#rotationsteps)

> **rotationSteps**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:185](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L185)

Clockwise 60-degree rotation steps.

***

### scale

[Section titled “scale”](#scale)

> **scale**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:189](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L189)

Uniform render scale.

***

### stackIndex?

[Section titled “stackIndex?”](#stackindex)

> `optional` **stackIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:193](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L193)

Optional stack index for vertical or layered pieces.

***

### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:179](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L179)

KayKit texture set applied to this placement.

***

### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:167](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L167)

Origin tile key in `q,r` form.

# GameboardPlacementTileRecord

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:108](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L108)

Relation payload connecting a placement to its origin tile.

## Properties

[Section titled “Properties”](#properties)

### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:114](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L114)

Origin tile coordinates.

***

### placementId

[Section titled “placementId”](#placementid)

> **placementId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:110](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L110)

Placement id.

***

### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:112](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L112)

Origin tile key.

# GameboardPlan

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:203](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L203)

Complete serializable gameboard plan.

## Properties

[Section titled “Properties”](#properties)

### placements

[Section titled “placements”](#placements)

> **placements**: readonly [`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:215](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L215)

Generated and custom placement specs.

***

### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> **schemaVersion**: `"1.0.0"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:205](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L205)

Schema version used to interpret this plan.

***

### seed

[Section titled “seed”](#seed)

> **seed**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:207](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L207)

Seed used to create this plan.

***

### shape

[Section titled “shape”](#shape)

> **shape**: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:209](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L209)

Board shape.

***

### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:211](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L211)

Active texture set.

***

### tiles

[Section titled “tiles”](#tiles)

> **tiles**: readonly [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:213](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L213)

Tile specs in the board.

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:217](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L217)

Non-fatal generation warnings.

# GameboardPlanAssetSummary

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:285](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L285)

Asset-level count and semantic treatment in a summarized gameboard plan.

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:287](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L287)

Manifest or external registry asset id.

***

### count

[Section titled “count”](#count)

> **count**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:289](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L289)

Number of placements that use the asset.

***

### features

[Section titled “features”](#features)

> **features**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:297](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L297)

Semantic features inferred from placement metadata or placement kind.

***

### kinds

[Section titled “kinds”](#kinds)

> **kinds**: readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:293](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L293)

Placement kinds where the asset appears.

***

### layers

[Section titled “layers”](#layers)

> **layers**: readonly [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:295](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L295)

Render/gameplay layers where the asset appears.

***

### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:291](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L291)

Whether any placement using this asset requires local-only assets.

# GameboardPlanFromTilesOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:350](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L350)

Options for creating a plan from already assembled tile and placement specs.

## Properties

[Section titled “Properties”](#properties)

### placements?

[Section titled “placements?”](#placements)

> `optional` **placements?**: readonly [`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:360](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L360)

Optional custom placements appended after derived terrain/connectivity placements.

***

### seed

[Section titled “seed”](#seed)

> **seed**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:352](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L352)

Seed to write into the plan.

***

### shape

[Section titled “shape”](#shape)

> **shape**: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:354](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L354)

Shape to write into the plan.

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:356](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L356)

Texture set to write into the plan.

***

### tiles

[Section titled “tiles”](#tiles)

> **tiles**: readonly [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:358](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L358)

Tile specs used by the plan.

***

### warnings?

[Section titled “warnings?”](#warnings)

> `optional` **warnings?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:362](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L362)

Optional non-fatal warnings.

# GameboardPlanIndex

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:229](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L229)

Memoized indexes derived from a [GameboardPlan](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/) (PRD B4).

Previously, hot-path callers in `coordinates/layout.ts` + `interop/interop.ts` rebuilt these maps on every invocation — 4+ calls per render frame. The indexes are now built once via [gameboardPlanIndex](/declarative-hex-worlds/reference/index/functions/gameboardplanindex/) and cached per-plan in a module-local WeakMap, so the second-and-later callers pay O(1) lookup instead of O(N) rebuild.

## Properties

[Section titled “Properties”](#properties)

### placementsByTile

[Section titled “placementsByTile”](#placementsbytile)

> `readonly` **placementsByTile**: `ReadonlyMap`<`string`, readonly [`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)\[]>

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:233](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L233)

Placement specs grouped by their tile’s `q,r` hexKey.

***

### tilesByKey

[Section titled “tilesByKey”](#tilesbykey)

> `readonly` **tilesByKey**: `ReadonlyMap`<`string`, [`GameboardTileSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardtilespec/)>

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:231](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L231)

Tile keyed by `q,r` hexKey.

# GameboardPlanOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:111](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L111)

Options for creating a generated gameboard plan.

## Properties

[Section titled “Properties”](#properties)

### defaultTerrain?

[Section titled “defaultTerrain?”](#defaultterrain)

> `optional` **defaultTerrain?**: `"grass"` | `"water"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:119](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L119)

Initial terrain used for every generated tile.

***

### seed?

[Section titled “seed?”](#seed)

> `optional` **seed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:113](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L113)

Deterministic seed for generation.

***

### shape

[Section titled “shape”](#shape)

> **shape**: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:115](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L115)

Board shape to populate.

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:117](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L117)

Texture set applied to generated terrain.

# GameboardPlanSummary

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:308](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L308)

Aggregate inspection result for a generated or projected gameboard plan.

This is designed for editor panels, CI diagnostics, screenshot manifests, external ECS bridges, and tests that need to prove which terrain, texture, elevation, placement, guide-feature, and local-only asset cases are present without reverse-engineering the raw tile and placement arrays.

## Properties

[Section titled “Properties”](#properties)

### assetCounts

[Section titled “assetCounts”](#assetcounts)

> **assetCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:340](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L340)

Placement count by asset id.

***

### extraAssetIds

[Section titled “extraAssetIds”](#extraassetids)

> **extraAssetIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:342](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L342)

Unique asset ids used by placements marked as requiring local-only assets.

***

### placementCount

[Section titled “placementCount”](#placementcount)

> **placementCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:320](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L320)

Number of generated and custom placement specs.

***

### placementFeatureCounts

[Section titled “placementFeatureCounts”](#placementfeaturecounts)

> **placementFeatureCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:338](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L338)

Placement count by metadata feature, falling back to placement kind.

***

### placementKindCounts

[Section titled “placementKindCounts”](#placementkindcounts)

> **placementKindCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:334](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L334)

Placement count by semantic kind.

***

### placementLayerCounts

[Section titled “placementLayerCounts”](#placementlayercounts)

> **placementLayerCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:336](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L336)

Placement count by render/gameplay layer.

***

### requiresExtraPlacementCount

[Section titled “requiresExtraPlacementCount”](#requiresextraplacementcount)

> **requiresExtraPlacementCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:324](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L324)

Number of placements marked as requiring local-only assets.

***

### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> **schemaVersion**: `"1.0.0"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:310](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L310)

Schema version used to interpret this plan.

***

### seed

[Section titled “seed”](#seed)

> **seed**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:312](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L312)

Seed used to create this plan.

***

### shape

[Section titled “shape”](#shape)

> **shape**: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:314](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L314)

Board shape.

***

### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:316](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L316)

Active texture set.

***

### tileCount

[Section titled “tileCount”](#tilecount)

> **tileCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:318](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L318)

Number of tile specs.

***

### tileElevationCounts

[Section titled “tileElevationCounts”](#tileelevationcounts)

> **tileElevationCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:330](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L330)

Tile count by stacked elevation level.

***

### tileTagCounts

[Section titled “tileTagCounts”](#tiletagcounts)

> **tileTagCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:332](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L332)

Tile tag counts derived from builder/connectivity metadata.

***

### tileTerrainCounts

[Section titled “tileTerrainCounts”](#tileterraincounts)

> **tileTerrainCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:326](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L326)

Tile count by terrain category.

***

### tileTextureSetCounts

[Section titled “tileTextureSetCounts”](#tiletexturesetcounts)

> **tileTextureSetCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:328](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L328)

Tile count by texture set.

***

### topAssets

[Section titled “topAssets”](#topassets)

> **topAssets**: readonly [`GameboardPlanAssetSummary`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanassetsummary/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:344](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L344)

Highest-frequency asset summaries, sorted by count then asset id.

***

### warningCount

[Section titled “warningCount”](#warningcount)

> **warningCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:322](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L322)

Number of non-fatal generation warnings.

# GameboardQuestActorReferenceRecord

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:288](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L288)

Relation payload connecting a quest objective to an actor.

## Properties

[Section titled “Properties”](#properties)

### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:294](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L294)

Actor id.

***

### objectiveId

[Section titled “objectiveId”](#objectiveid)

> **objectiveId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:292](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L292)

Objective id.

***

### questId

[Section titled “questId”](#questid)

> **questId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:290](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L290)

Quest id.

***

### role

[Section titled “role”](#role)

> **role**: [`GameboardQuestActorReferenceRole`](/declarative-hex-worlds/reference/index/type-aliases/gameboardquestactorreferencerole/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:296](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L296)

Reference role.

# GameboardQuestAdvancedEvent

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:175](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L175)

Quest state advanced but may not yet be completed.

## Properties

[Section titled “Properties”](#properties)

### before?

[Section titled “before?”](#before)

> `optional` **before?**: [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:179](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L179)

Quest snapshot before the advance.

***

### quest

[Section titled “quest”](#quest)

> **quest**: [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:181](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L181)

Quest snapshot after the advance.

***

### type

[Section titled “type”](#type)

> **type**: `"quest-advanced"`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:177](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L177)

Event discriminator.

# GameboardQuestBlockedEvent

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:199](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L199)

Quest became blocked during a system pass.

## Properties

[Section titled “Properties”](#properties)

### before?

[Section titled “before?”](#before)

> `optional` **before?**: [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:203](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L203)

Quest snapshot before the blocked state.

***

### quest

[Section titled “quest”](#quest)

> **quest**: [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:205](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L205)

Quest snapshot after the blocked state.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:207](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L207)

Blocked reason from objective progress.

***

### type

[Section titled “type”](#type)

> **type**: `"quest-blocked"`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:201](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L201)

Event discriminator.

# GameboardQuestCompletedEvent

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:187](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L187)

Quest completed during a system pass.

## Properties

[Section titled “Properties”](#properties)

### before?

[Section titled “before?”](#before)

> `optional` **before?**: [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:191](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L191)

Quest snapshot before completion.

***

### quest

[Section titled “quest”](#quest)

> **quest**: [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:193](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L193)

Quest snapshot after completion.

***

### type

[Section titled “type”](#type)

> **type**: `"quest-completed"`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:189](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L189)

Event discriminator.

# GameboardQuestDefinition

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L47)

Serializable quest definition.

## Properties

[Section titled “Properties”](#properties)

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:49](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L49)

Stable quest id.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, [`GameboardQuestMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestmetadatavalue/)>>

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:55](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L55)

Serializable quest metadata.

***

### objectives

[Section titled “objectives”](#objectives)

> **objectives**: readonly [`GameboardQuestObjective`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestobjective/)\[]

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:53](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L53)

Ordered quest objectives.

***

### title?

[Section titled “title?”](#title)

> `optional` **title?**: `string`

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:51](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L51)

Optional display title.

# GameboardQuestEventRecord

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:332](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L332)

Serializable quest event record.

## Properties

[Section titled “Properties”](#properties)

### activeObjectiveId?

[Section titled “activeObjectiveId?”](#activeobjectiveid)

> `optional` **activeObjectiveId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:342](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L342)

Active objective id.

***

### activeObjectiveIndex

[Section titled “activeObjectiveIndex”](#activeobjectiveindex)

> **activeObjectiveIndex**: `number`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:340](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L340)

Active objective index.

***

### objectives

[Section titled “objectives”](#objectives)

> **objectives**: readonly [`GameboardQuestObjective`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestobjective/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:344](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L344)

Quest objectives.

***

### progress

[Section titled “progress”](#progress)

> **progress**: readonly [`GameboardQuestObjectiveProgress`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectiveprogress/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:346](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L346)

Objective progress snapshots.

***

### questId

[Section titled “questId”](#questid)

> **questId**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:334](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L334)

Quest id.

***

### status

[Section titled “status”](#status)

> **status**: [`GameboardQuestStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardqueststatus/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:338](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L338)

Quest status.

***

### title

[Section titled “title”](#title)

> **title**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:336](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L336)

Quest title.

# GameboardQuestObjectiveEvaluation

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:112](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L112)

Result of evaluating one objective.

## Properties

[Section titled “Properties”](#properties)

### collision?

[Section titled “collision?”](#collision)

> `optional` **collision?**: [`GameboardActorCollisionReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionreport/)

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:122](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L122)

Collision report, for collision objectives.

***

### objective

[Section titled “objective”](#objective)

> **objective**: [`GameboardQuestObjective`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestobjective/)

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:114](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L114)

Objective that was evaluated.

***

### progress

[Section titled “progress”](#progress)

> **progress**: [`GameboardQuestObjectiveProgress`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectiveprogress/)

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:116](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L116)

Progress produced by evaluation.

***

### source?

[Section titled “source?”](#source)

> `optional` **source?**: [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:118](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L118)

Source actor, when resolved.

***

### target?

[Section titled “target?”](#target)

> `optional` **target?**: [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:120](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L120)

Target actor, when resolved.

# GameboardQuestSnapshot

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:84](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L84)

Joined quest entity and quest trait state.

## Properties

[Section titled “Properties”](#properties)

### entity

[Section titled “entity”](#entity)

> **entity**: `Entity`

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L86)

Live Koota quest entity.

***

### quest

[Section titled “quest”](#quest)

> **quest**: `object`

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L88)

Quest trait value.

#### activeObjectiveIndex

[Section titled “activeObjectiveIndex”](#activeobjectiveindex)

> **activeObjectiveIndex**: `number` = `0`

Index of the active objective in `objectives`.

#### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Record`<`string`, [`GameboardQuestMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestmetadatavalue/)>

Serializable quest metadata.

#### objectives

[Section titled “objectives”](#objectives)

> **objectives**: [`GameboardQuestObjective`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestobjective/)\[]

Ordered objective definitions.

#### progress

[Section titled “progress”](#progress)

> **progress**: [`GameboardQuestObjectiveProgress`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectiveprogress/)\[]

Objective progress records.

#### questId

[Section titled “questId”](#questid)

> **questId**: `string` = `''`

Stable quest id.

#### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> **schemaVersion**: `string` = `GAMEBOARD_QUEST_SCHEMA_VERSION`

Quest schema version.

#### status

[Section titled “status”](#status)

> **status**: [`GameboardQuestStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardqueststatus/)

Runtime quest lifecycle status.

#### title

[Section titled “title”](#title)

> **title**: `string` = `''`

Quest display title.

# GameboardQuestTileReferenceRecord

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:307](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L307)

Relation payload connecting a quest objective to a tile.

## Properties

[Section titled “Properties”](#properties)

### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:315](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L315)

Tile coordinates.

***

### objectiveId

[Section titled “objectiveId”](#objectiveid)

> **objectiveId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:311](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L311)

Objective id.

***

### questId

[Section titled “questId”](#questid)

> **questId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:309](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L309)

Quest id.

***

### role

[Section titled “role”](#role)

> **role**: [`GameboardQuestTileReferenceRole`](/declarative-hex-worlds/reference/index/type-aliases/gameboardquesttilereferencerole/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:317](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L317)

Reference role.

***

### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:313](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L313)

Tile key.

# GameboardRecipeGameRuntime

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:654](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L654)

Runtime facade created from a recipe, preserving recipe-specific registries.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/)

## Properties

[Section titled “Properties”](#properties)

### actions

[Section titled “actions”](#actions)

> `readonly` **actions**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:308](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L308)

Raw board placement actions.

#### canOccupyPlacement

[Section titled “canOccupyPlacement”](#canoccupyplacement)

> **canOccupyPlacement**: (`options`) => `boolean`

Return only the boolean occupancy result for a proposed placement.

##### Parameters

[Section titled “Parameters”](#parameters)

###### options

[Section titled “options”](#options)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/)

##### Returns

[Section titled “Returns”](#returns)

`boolean`

#### clear

[Section titled “clear”](#clear)

> **clear**: () => `void`

Remove all board tile, placement, and board-state traits from the world.

##### Returns

[Section titled “Returns”](#returns-1)

`void`

#### inspectPlacementOccupancy

[Section titled “inspectPlacementOccupancy”](#inspectplacementoccupancy)

> **inspectPlacementOccupancy**: (`options`) => [`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/)

Inspect whether a proposed placement footprint can occupy its target tiles.

##### Parameters

[Section titled “Parameters”](#parameters-1)

###### options

[Section titled “options”](#options-1)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/)

##### Returns

[Section titled “Returns”](#returns-2)

[`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/)

#### loadPlan

[Section titled “loadPlan”](#loadplan)

> **loadPlan**: (`plan`) => [`GameboardEntityIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardentityindex/)

Replace the current world contents with a complete generated board plan.

##### Parameters

[Section titled “Parameters”](#parameters-2)

###### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

##### Returns

[Section titled “Returns”](#returns-3)

[`GameboardEntityIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardentityindex/)

#### movePlacement

[Section titled “movePlacement”](#moveplacement)

> **movePlacement**: (`placement`, `to`, `options`) => `Entity`

Move an existing placement to another tile while preserving unspecified state.

##### Parameters

[Section titled “Parameters”](#parameters-3)

###### placement

[Section titled “placement”](#placement)

`string` | `Entity`

###### to

[Section titled “to”](#to)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

###### options?

[Section titled “options?”](#options-2)

[`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-4)

`Entity`

#### removePlacement

[Section titled “removePlacement”](#removeplacement)

> **removePlacement**: (`placement`) => `boolean`

Remove an existing placement by entity or placement id.

##### Parameters

[Section titled “Parameters”](#parameters-4)

###### placement

[Section titled “placement”](#placement-1)

`string` | `Entity`

##### Returns

[Section titled “Returns”](#returns-5)

`boolean`

#### spawnPlacement

[Section titled “spawnPlacement”](#spawnplacement)

> **spawnPlacement**: (`options`) => `Entity`

Spawn a runtime placement into the board.

##### Parameters

[Section titled “Parameters”](#parameters-5)

###### options

[Section titled “options”](#options-3)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)

##### Returns

[Section titled “Returns”](#returns-6)

`Entity`

#### updatePlacement

[Section titled “updatePlacement”](#updateplacement)

> **updatePlacement**: (`placement`, `options`) => `Entity`

Update an existing runtime placement by entity or placement id.

##### Parameters

[Section titled “Parameters”](#parameters-6)

###### placement

[Section titled “placement”](#placement-2)

`string` | `Entity`

###### options

[Section titled “options”](#options-4)

[`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/)

##### Returns

[Section titled “Returns”](#returns-7)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`actions`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#actions)

***

### actors

[Section titled “actors”](#actors)

> `readonly` **actors**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:310](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L310)

Actor actions.

#### collision

[Section titled “collision”](#collision)

> **collision**: (`actor`, `target`, `profile`) => [`GameboardActorCollisionReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionreport/)

Inspect whether an actor can enter a target tile.

##### Parameters

[Section titled “Parameters”](#parameters-7)

###### actor

[Section titled “actor”](#actor)

`string` | `Entity` | `undefined`

###### target

[Section titled “target”](#target)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

###### profile?

[Section titled “profile?”](#profile)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/) = `{}`

##### Returns

[Section titled “Returns”](#returns-8)

[`GameboardActorCollisionReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionreport/)

#### command

[Section titled “command”](#command)

> **command**: (`target`, `options`) => [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

Plan a high-level interaction command from a target input.

##### Parameters

[Section titled “Parameters”](#parameters-8)

###### target

[Section titled “target”](#target-1)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

###### options?

[Section titled “options?”](#options-5)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-9)

[`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

#### interaction

[Section titled “interaction”](#interaction)

> **interaction**: (`target`, `options`) => [`GameboardInteractionTargetReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetreport/)

Resolve and inspect an interaction target.

##### Parameters

[Section titled “Parameters”](#parameters-9)

###### target

[Section titled “target”](#target-2)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

###### options?

[Section titled “options?”](#options-6)

[`GameboardInteractionTargetOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-10)

[`GameboardInteractionTargetReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetreport/)

#### move

[Section titled “move”](#move)

> **move**: (`actor`, `to`, `options`) => `Entity`

Move an actor to another tile.

##### Parameters

[Section titled “Parameters”](#parameters-10)

###### actor

[Section titled “actor”](#actor-1)

`string` | `Entity`

###### to

[Section titled “to”](#to-1)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

###### options?

[Section titled “options?”](#options-7)

[`MoveGameboardActorOptions`](/declarative-hex-worlds/reference/index/type-aliases/movegameboardactoroptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-11)

`Entity`

#### navigationProfile

[Section titled “navigationProfile”](#navigationprofile)

> **navigationProfile**: (`actor`, `options`) => [`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

Create an actor-aware navigation profile.

##### Parameters

[Section titled “Parameters”](#parameters-11)

###### actor

[Section titled “actor”](#actor-2)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-8)

[`GameboardActorNavigationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactornavigationoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-12)

[`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

#### neighborhood

[Section titled “neighborhood”](#neighborhood)

> **neighborhood**: (`center`, `options`) => [`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

Inspect a radius of tiles around a center.

##### Parameters

[Section titled “Parameters”](#parameters-12)

###### center

[Section titled “center”](#center)

[`GameboardNeighborhoodCenter`](/declarative-hex-worlds/reference/index/type-aliases/gameboardneighborhoodcenter/)

###### options?

[Section titled “options?”](#options-9)

[`GameboardNeighborhoodInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspectionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-13)

[`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

#### read

[Section titled “read”](#read)

> **read**: () => [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Read all registered actors.

##### Returns

[Section titled “Returns”](#returns-14)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

#### register

[Section titled “register”](#register)

> **register**: (`placement`, `options`) => `Entity`

Register an existing placement as an actor.

##### Parameters

[Section titled “Parameters”](#parameters-13)

###### placement

[Section titled “placement”](#placement-3)

`string` | `Entity`

###### options

[Section titled “options”](#options-10)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/)

##### Returns

[Section titled “Returns”](#returns-15)

`Entity`

#### select

[Section titled “select”](#select)

> **select**: (`options`) => [`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

Select actors with optional faction, team, tag, radius, and hostility filters.

##### Parameters

[Section titled “Parameters”](#parameters-14)

###### options?

[Section titled “options?”](#options-11)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-16)

[`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

#### spawn

[Section titled “spawn”](#spawn)

> **spawn**: (`options`) => `Entity`

Spawn a placement and register it as an actor.

##### Parameters

[Section titled “Parameters”](#parameters-15)

###### options

[Section titled “options”](#options-12)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/)

##### Returns

[Section titled “Returns”](#returns-17)

`Entity`

#### targets

[Section titled “targets”](#targets)

> **targets**: (`options`) => [`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/)

Select and path to candidate actor targets.

##### Parameters

[Section titled “Parameters”](#parameters-16)

###### options

[Section titled “options”](#options-13)

[`GameboardActorTargetingOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/)

##### Returns

[Section titled “Returns”](#returns-18)

[`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/)

#### tile

[Section titled “tile”](#tile)

> **tile**: (`coordinates`, `options`) => [`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

Inspect one tile from an actor/gameplay perspective.

##### Parameters

[Section titled “Parameters”](#parameters-17)

###### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

###### options?

[Section titled “options?”](#options-14)

[`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-19)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

#### update

[Section titled “update”](#update)

> **update**: (`actor`, `options`) => `Entity`

Update actor trait state while preserving omitted fields.

##### Parameters

[Section titled “Parameters”](#parameters-18)

###### actor

[Section titled “actor”](#actor-3)

`string` | `Entity`

###### options

[Section titled “options”](#options-15)

[`UpdateGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardactoroptions/)

##### Returns

[Section titled “Returns”](#returns-20)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`actors`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#actors)

***

### advanceAllQuests

[Section titled “advanceAllQuests”](#advanceallquests)

> **advanceAllQuests**: (`options?`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:571](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L571)

Advance every quest against the current live actor, placement, and tile state.

#### Parameters

[Section titled “Parameters”](#parameters-19)

##### options?

[Section titled “options?”](#options-16)

[`AdvanceGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardquestoptions/)

#### Returns

[Section titled “Returns”](#returns-21)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`advanceAllQuests`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#advanceallquests)

***

### advanceQuest

[Section titled “advanceQuest”](#advancequest)

> **advanceQuest**: (`quest`, `options?`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:566](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L566)

Advance one quest against the current live actor, placement, and tile state.

#### Parameters

[Section titled “Parameters”](#parameters-20)

##### quest

[Section titled “quest”](#quest)

`string` | `Entity`

##### options?

[Section titled “options?”](#options-17)

[`AdvanceGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardquestoptions/)

#### Returns

[Section titled “Returns”](#returns-22)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`advanceQuest`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#advancequest)

***

### analyzeLayoutFill

[Section titled “analyzeLayoutFill”](#analyzelayoutfill)

> **analyzeLayoutFill**: (`options`) => [`GameboardLayoutFillAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillanalysis/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:447](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L447)

Analyze seeded layout fill rules against the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-21)

##### options

[Section titled “options”](#options-18)

[`GameboardLayoutFillOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfilloptions/)

#### Returns

[Section titled “Returns”](#returns-23)

[`GameboardLayoutFillAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillanalysis/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`analyzeLayoutFill`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#analyzelayoutfill)

***

### analyzePieceFills

[Section titled “analyzePieceFills”](#analyzepiecefills)

> **analyzePieceFills**: (`registry`, `fills`, `options?`) => [`GameboardLayoutFillAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillanalysis/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:497](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L497)

Analyze generated piece fills against the current projected plan.

#### Parameters

[Section titled “Parameters”](#parameters-22)

##### registry

[Section titled “registry”](#registry)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### fills

[Section titled “fills”](#fills)

readonly [`SeededGameboardPieceFillOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefilloptions/)\[]

##### options?

[Section titled “options?”](#options-19)

[`InspectSeededGameboardPieceFillsOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectseededgameboardpiecefillsoptions/)

#### Returns

[Section titled “Returns”](#returns-24)

[`GameboardLayoutFillAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillanalysis/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`analyzePieceFills`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#analyzepiecefills)

***

### analyzePieceRegistry

[Section titled “analyzePieceRegistry”](#analyzepieceregistry)

> **analyzePieceRegistry**: (`registry`, `options?`) => [`GameboardPieceRegistryAnalysis`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryanalysis/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:477](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L477)

Analyze a custom piece registry.

#### Parameters

[Section titled “Parameters”](#parameters-23)

##### registry

[Section titled “registry”](#registry-1)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### options?

[Section titled “options?”](#options-20)

[`AnalyzeGameboardPieceRegistryOptions`](/declarative-hex-worlds/reference/index/interfaces/analyzegameboardpieceregistryoptions/)

#### Returns

[Section titled “Returns”](#returns-25)

[`GameboardPieceRegistryAnalysis`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryanalysis/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`analyzePieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#analyzepieceregistry)

***

### canOccupyPlacement

[Section titled “canOccupyPlacement”](#canoccupyplacement-1)

> **canOccupyPlacement**: (`options`) => `boolean`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:369](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L369)

Return the boolean result from `inspectPlacementOccupancy`.

#### Parameters

[Section titled “Parameters”](#parameters-24)

##### options

[Section titled “options”](#options-21)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/)

#### Returns

[Section titled “Returns”](#returns-26)

`boolean`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`canOccupyPlacement`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#canoccupyplacement)

***

### commands

[Section titled “commands”](#commands)

> `readonly` **commands**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:318](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L318)

Command planning/execution actions.

#### execute

[Section titled “execute”](#execute)

> **execute**: (`commandOrTarget`, `options`) => [`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

Execute a command with optional host-game handlers.

##### Parameters

[Section titled “Parameters”](#parameters-25)

###### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

###### options?

[Section titled “options?”](#options-22)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-27)

[`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

#### plan

[Section titled “plan”](#plan-1)

> **plan**: (`target`, `options`) => [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

Plan a command from a renderer or gameplay target.

##### Parameters

[Section titled “Parameters”](#parameters-26)

###### target

[Section titled “target”](#target-3)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

###### options?

[Section titled “options?”](#options-23)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-28)

[`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

#### preview

[Section titled “preview”](#preview)

> **preview**: (`commandOrTarget`, `options`) => [`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

Preview a command without mutating state.

##### Parameters

[Section titled “Parameters”](#parameters-27)

###### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-1)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

###### options?

[Section titled “options?”](#options-24)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-29)

[`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

#### targetCommand

[Section titled “targetCommand”](#targetcommand)

> **targetCommand**: (`options`) => [`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

Select an actor target and plan a command against it.

##### Parameters

[Section titled “Parameters”](#parameters-28)

###### options

[Section titled “options”](#options-25)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

##### Returns

[Section titled “Returns”](#returns-30)

[`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`commands`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#commands)

***

### createInteropSnapshot

[Section titled “createInteropSnapshot”](#createinteropsnapshot)

> **createInteropSnapshot**: (`options?`) => [`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:420](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L420)

Create an ECS interop snapshot from the live runtime.

#### Parameters

[Section titled “Parameters”](#parameters-29)

##### options?

[Section titled “options?”](#options-26)

[`GameboardRuntimeInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimeinteropoptions/)

#### Returns

[Section titled “Returns”](#returns-31)

[`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createinteropsnapshot)

***

### createLayoutFillPlacements

[Section titled “createLayoutFillPlacements”](#createlayoutfillplacements)

> **createLayoutFillPlacements**: (`options`) => [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:449](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L449)

Create seeded layout fill placement options without mutating the live world.

#### Parameters

[Section titled “Parameters”](#parameters-30)

##### options

[Section titled “options”](#options-27)

[`GameboardLayoutFillOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfilloptions/)

#### Returns

[Section titled “Returns”](#returns-32)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createLayoutFillPlacements`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createlayoutfillplacements)

***

### createLayoutPlacements

[Section titled “createLayoutPlacements”](#createlayoutplacements)

> **createLayoutPlacements**: (`options`) => [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:443](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L443)

Create layout placement spawn options without mutating the live world.

#### Parameters

[Section titled “Parameters”](#parameters-31)

##### options

[Section titled “options”](#options-28)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-33)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createLayoutPlacements`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createlayoutplacements)

***

### createNavigation

[Section titled “createNavigation”](#createnavigation)

> **createNavigation**: (`profile?`) => [`GameboardNavigation`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigation/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:429](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L429)

Create a pathfinding/navigation facade from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-32)

##### profile?

[Section titled “profile?”](#profile-1)

[`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

#### Returns

[Section titled “Returns”](#returns-34)

[`GameboardNavigation`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigation/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createNavigation`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createnavigation)

***

### createOccupancyIndex

[Section titled “createOccupancyIndex”](#createoccupancyindex)

> **createOccupancyIndex**: (`profile?`) => [`GameboardOccupancyIndex`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardoccupancyindex/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:427](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L427)

Create a navigation occupancy index from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-33)

##### profile?

[Section titled “profile?”](#profile-2)

[`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

#### Returns

[Section titled “Returns”](#returns-35)

[`GameboardOccupancyIndex`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardoccupancyindex/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createOccupancyIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createoccupancyindex)

***

### createPieceFillRules

[Section titled “createPieceFillRules”](#createpiecefillrules)

> **createPieceFillRules**: (`registry`, `options?`) => [`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:487](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L487)

Create layout fill rules from selected registry pieces.

#### Parameters

[Section titled “Parameters”](#parameters-34)

##### registry

[Section titled “registry”](#registry-2)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### options?

[Section titled “options?”](#options-29)

[`GameboardPieceRegistryFillRulesOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryfillrulesoptions/)

#### Returns

[Section titled “Returns”](#returns-36)

[`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-14)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createPieceFillRules`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createpiecefillrules)

***

### createPiecePlacementOptions

[Section titled “createPiecePlacementOptions”](#createpieceplacementoptions)

> **createPiecePlacementOptions**: (`piece`, `options?`) => [`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:457](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L457)

Convert a piece declaration to layout placement options.

#### Parameters

[Section titled “Parameters”](#parameters-35)

##### piece

[Section titled “piece”](#piece)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

##### options?

[Section titled “options?”](#options-30)

[`GameboardPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-37)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-15)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createpieceplacementoptions)

***

### createPiecePlacements

[Section titled “createPiecePlacements”](#createpieceplacements)

> **createPiecePlacements**: (`piece`, `options?`) => [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:462](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L462)

Create placement options for a piece against the current projected plan.

#### Parameters

[Section titled “Parameters”](#parameters-36)

##### piece

[Section titled “piece”](#piece-1)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

##### options?

[Section titled “options?”](#options-31)

[`GameboardPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-38)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-16)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createPiecePlacements`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createpieceplacements)

***

### createPiecePoolFillRule

[Section titled “createPiecePoolFillRule”](#createpiecepoolfillrule)

> **createPiecePoolFillRule**: (`pieces`, `options?`) => [`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:492](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L492)

Create one pooled fill rule from a piece collection.

#### Parameters

[Section titled “Parameters”](#parameters-37)

##### pieces

[Section titled “pieces”](#pieces)

readonly [`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)\[]

##### options?

[Section titled “options?”](#options-32)

[`GameboardPieceCollectionLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiececollectionlayoutruleoptions/)

#### Returns

[Section titled “Returns”](#returns-39)

[`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-17)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createPiecePoolFillRule`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createpiecepoolfillrule)

***

### createPieceSourceUrlMap

[Section titled “createPieceSourceUrlMap”](#createpiecesourceurlmap)

> **createPieceSourceUrlMap**: (`registry`, `options?`) => `Readonly`<`Record`<`string`, `string`>>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:515](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L515)

Create an asset-id-to-URL map for local custom pieces.

#### Parameters

[Section titled “Parameters”](#parameters-38)

##### registry

[Section titled “registry”](#registry-3)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### options?

[Section titled “options?”](#options-33)

[`GameboardPieceSourceUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecesourceurloptions/)

#### Returns

[Section titled “Returns”](#returns-40)

`Readonly`<`Record`<`string`, `string`>>

#### Inherited from

[Section titled “Inherited from”](#inherited-from-18)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createPieceSourceUrlMap`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createpiecesourceurlmap)

***

### createRecipePieceSourceUrlMap

[Section titled “createRecipePieceSourceUrlMap”](#createrecipepiecesourceurlmap)

> **createRecipePieceSourceUrlMap**: (`options?`) => `Readonly`<`Record`<`string`, `string`>>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:662](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L662)

Create an asset-id-to-URL map for recipe-local custom pieces.

#### Parameters

[Section titled “Parameters”](#parameters-39)

##### options?

[Section titled “options?”](#options-34)

[`GameboardPieceSourceUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecesourceurloptions/)

#### Returns

[Section titled “Returns”](#returns-41)

`Readonly`<`Record`<`string`, `string`>>

***

### dispatchActorTargetCommand

[Section titled “dispatchActorTargetCommand”](#dispatchactortargetcommand)

> **dispatchActorTargetCommand**: (`options`, `commandOptions?`) => [`DispatchGameboardActorTargetCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardactortargetcommandresult/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:592](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L592)

Select an actor target and dispatch the planned command.

#### Parameters

[Section titled “Parameters”](#parameters-40)

##### options

[Section titled “options”](#options-35)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

##### commandOptions?

[Section titled “commandOptions?”](#commandoptions)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/)

#### Returns

[Section titled “Returns”](#returns-42)

[`DispatchGameboardActorTargetCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardactortargetcommandresult/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-19)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`dispatchActorTargetCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#dispatchactortargetcommand)

***

### dispatchCommand

[Section titled “dispatchCommand”](#dispatchcommand)

> **dispatchCommand**: (`commandOrTarget`, `options?`) => [`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:587](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L587)

Execute a command and return dispatch events.

#### Parameters

[Section titled “Parameters”](#parameters-41)

##### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-2)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

##### options?

[Section titled “options?”](#options-36)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/)

#### Returns

[Section titled “Returns”](#returns-43)

[`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-20)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`dispatchCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#dispatchcommand)

***

### executeCommand

[Section titled “executeCommand”](#executecommand)

> **executeCommand**: (`commandOrTarget`, `options?`) => [`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:597](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L597)

Execute a command without wrapping it in system events.

#### Parameters

[Section titled “Parameters”](#parameters-42)

##### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-3)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

##### options?

[Section titled “options?”](#options-37)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/)

#### Returns

[Section titled “Returns”](#returns-44)

[`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-21)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`executeCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#executecommand)

***

### findActor

[Section titled “findActor”](#findactor)

> **findActor**: (`actor`) => [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:535](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L535)

Find one actor by entity, placement id, or stable actor id.

#### Parameters

[Section titled “Parameters”](#parameters-43)

##### actor

[Section titled “actor”](#actor-4)

`string` | `Entity`

#### Returns

[Section titled “Returns”](#returns-45)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/) | `undefined`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-22)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`findActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#findactor)

***

### findQuest

[Section titled “findQuest”](#findquest)

> **findQuest**: (`quest`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:562](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L562)

Find one quest by entity or stable quest id.

#### Parameters

[Section titled “Parameters”](#parameters-44)

##### quest

[Section titled “quest”](#quest-1)

`string` | `Entity`

#### Returns

[Section titled “Returns”](#returns-46)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/) | `undefined`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-23)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`findQuest`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#findquest)

***

### inspectActorTargets

[Section titled “inspectActorTargets”](#inspectactortargets)

> **inspectActorTargets**: (`options`) => [`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:418](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L418)

Select and rank actor targets with path and command planning.

#### Parameters

[Section titled “Parameters”](#parameters-45)

##### options

[Section titled “options”](#options-38)

[`GameboardActorTargetingOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/)

#### Returns

[Section titled “Returns”](#returns-47)

[`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-24)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`inspectActorTargets`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#inspectactortargets)

***

### inspectLayoutSites

[Section titled “inspectLayoutSites”](#inspectlayoutsites)

> **inspectLayoutSites**: (`options?`) => [`GameboardLayoutSiteInspection`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutsiteinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:439](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L439)

Inspect layout candidates and rejections against the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-46)

##### options?

[Section titled “options?”](#options-39)

[`InspectGameboardLayoutSitesOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/inspectgameboardlayoutsitesoptions/)

#### Returns

[Section titled “Returns”](#returns-48)

[`GameboardLayoutSiteInspection`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutsiteinspection/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-25)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`inspectLayoutSites`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#inspectlayoutsites)

***

### inspectNeighborhood

[Section titled “inspectNeighborhood”](#inspectneighborhood)

> **inspectNeighborhood**: (`center`, `options?`) => [`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:411](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L411)

Inspect a radius around a tile, placement, actor, or coordinate.

#### Parameters

[Section titled “Parameters”](#parameters-47)

##### center

[Section titled “center”](#center-1)

[`GameboardNeighborhoodCenter`](/declarative-hex-worlds/reference/index/type-aliases/gameboardneighborhoodcenter/)

##### options?

[Section titled “options?”](#options-40)

[`GameboardNeighborhoodInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspectionoptions/)

#### Returns

[Section titled “Returns”](#returns-49)

[`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-26)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`inspectNeighborhood`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#inspectneighborhood)

***

### inspectPieceFills

[Section titled “inspectPieceFills”](#inspectpiecefills)

> **inspectPieceFills**: (`registry`, `fills`, `options?`) => [`SeededGameboardPieceFillInspection`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefillinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:503](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L503)

Inspect generated piece fills with candidate and rejection details.

#### Parameters

[Section titled “Parameters”](#parameters-48)

##### registry

[Section titled “registry”](#registry-4)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### fills

[Section titled “fills”](#fills-1)

readonly [`SeededGameboardPieceFillOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefilloptions/)\[]

##### options?

[Section titled “options?”](#options-41)

[`InspectSeededGameboardPieceFillsOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectseededgameboardpiecefillsoptions/)

#### Returns

[Section titled “Returns”](#returns-50)

[`SeededGameboardPieceFillInspection`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefillinspection/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-27)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`inspectPieceFills`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#inspectpiecefills)

***

### inspectPiecePlacement

[Section titled “inspectPiecePlacement”](#inspectpieceplacement)

> **inspectPiecePlacement**: (`piece`, `options?`) => [`GameboardPiecePlacementInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:467](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L467)

Inspect where a piece can be placed against the current projected plan.

#### Parameters

[Section titled “Parameters”](#parameters-49)

##### piece

[Section titled “piece”](#piece-2)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

##### options?

[Section titled “options?”](#options-42)

[`GameboardPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-51)

[`GameboardPiecePlacementInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementinspection/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-28)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`inspectPiecePlacement`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#inspectpieceplacement)

***

### inspectPlacementOccupancy

[Section titled “inspectPlacementOccupancy”](#inspectplacementoccupancy-1)

> **inspectPlacementOccupancy**: (`options`) => [`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:365](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L365)

Inspect whether a placement footprint can occupy the current live board.

This is the preflight path for construction cursors, drag previews, unit moves, and generated fills before mutating the world.

#### Parameters

[Section titled “Parameters”](#parameters-50)

##### options

[Section titled “options”](#options-43)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/)

#### Returns

[Section titled “Returns”](#returns-52)

[`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-29)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`inspectPlacementOccupancy`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#inspectplacementoccupancy)

***

### inspectTile

[Section titled “inspectTile”](#inspecttile)

> **inspectTile**: (`coordinates`, `options?`) => [`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:406](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L406)

Inspect one tile, placement, actor, or coordinate in live state.

#### Parameters

[Section titled “Parameters”](#parameters-51)

##### coordinates

[Section titled “coordinates”](#coordinates-1)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### options?

[Section titled “options?”](#options-44)

[`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/)

#### Returns

[Section titled “Returns”](#returns-53)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-30)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`inspectTile`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#inspecttile)

***

### interact

[Section titled “interact”](#interact)

> **interact**: (`commandOrTarget`, `options?`) => [`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:602](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L602)

Dispatch a command and optionally run systems.

#### Parameters

[Section titled “Parameters”](#parameters-52)

##### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-4)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

##### options?

[Section titled “options?”](#options-45)

[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/)

#### Returns

[Section titled “Returns”](#returns-54)

[`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-31)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`interact`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#interact)

***

### interactActorTarget

[Section titled “interactActorTarget”](#interactactortarget)

> **interactActorTarget**: (`options`, `interactionOptions?`) => [`RunGameboardActorTargetInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardactortargetinteractionresult/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:607](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L607)

Target an actor, dispatch the command, and optionally run systems.

#### Parameters

[Section titled “Parameters”](#parameters-53)

##### options

[Section titled “options”](#options-46)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

##### interactionOptions?

[Section titled “interactionOptions?”](#interactionoptions)

[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/)

#### Returns

[Section titled “Returns”](#returns-55)

[`RunGameboardActorTargetInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardactortargetinteractionresult/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-32)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`interactActorTarget`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#interactactortarget)

***

### loadPlan

[Section titled “loadPlan”](#loadplan-1)

> **loadPlan**: (`plan`) => [`GameboardEntityIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardentityindex/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:322](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L322)

Load a plan into the bound world.

#### Parameters

[Section titled “Parameters”](#parameters-54)

##### plan

[Section titled “plan”](#plan-2)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

#### Returns

[Section titled “Returns”](#returns-56)

[`GameboardEntityIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardentityindex/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-33)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`loadPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#loadplan)

***

### mountInterop

[Section titled “mountInterop”](#mountinterop)

> **mountInterop**: <`TEntity`>(`adapter`, `options?`) => [`GameboardEcsMountResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsmountresult/)<`TEntity`>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:422](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L422)

Mount the live runtime snapshot into another ECS/store adapter.

#### Type Parameters

[Section titled “Type Parameters”](#type-parameters)

##### TEntity

[Section titled “TEntity”](#tentity)

`TEntity`

#### Parameters

[Section titled “Parameters”](#parameters-55)

##### adapter

[Section titled “adapter”](#adapter)

[`GameboardEcsAdapter`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsadapter/)<`TEntity`>

##### options?

[Section titled “options?”](#options-47)

[`GameboardRuntimeInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimeinteropoptions/)

#### Returns

[Section titled “Returns”](#returns-57)

[`GameboardEcsMountResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsmountresult/)<`TEntity`>

#### Inherited from

[Section titled “Inherited from”](#inherited-from-34)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`mountInterop`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#mountinterop)

***

### moveActor

[Section titled “moveActor”](#moveactor)

> **moveActor**: (`actor`, `to`, `options?`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:546](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L546)

Move an actor-backed placement by actor id or entity.

#### Parameters

[Section titled “Parameters”](#parameters-56)

##### actor

[Section titled “actor”](#actor-5)

`string` | `Entity`

##### to

[Section titled “to”](#to-2)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### options?

[Section titled “options?”](#options-48)

[`MoveGameboardActorOptions`](/declarative-hex-worlds/reference/index/type-aliases/movegameboardactoroptions/)

#### Returns

[Section titled “Returns”](#returns-58)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-35)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`moveActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#moveactor)

***

### movement

[Section titled “movement”](#movement)

> `readonly` **movement**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:312](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L312)

Movement actions.

#### advance

[Section titled “advance”](#advance)

> **advance**: (`placement`, `options`) => [`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)

Advance one placement along its requested path.

##### Parameters

[Section titled “Parameters”](#parameters-57)

###### placement

[Section titled “placement”](#placement-4)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-49)

[`AdvanceGameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardmovementoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-59)

[`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)

#### clear

[Section titled “clear”](#clear-1)

> **clear**: (`placement`) => `Entity`

Clear active movement path state for a placement.

##### Parameters

[Section titled “Parameters”](#parameters-58)

###### placement

[Section titled “placement”](#placement-5)

`string` | `Entity`

##### Returns

[Section titled “Returns”](#returns-60)

`Entity`

#### reachable

[Section titled “reachable”](#reachable)

> **reachable**: (`placement`, `options`) => [`GameboardReachableTile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardreachabletile/)\[]

Return tiles reachable by one movement agent.

##### Parameters

[Section titled “Parameters”](#parameters-59)

###### placement

[Section titled “placement”](#placement-6)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-50)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-61)

[`GameboardReachableTile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardreachabletile/)\[]

#### requestMove

[Section titled “requestMove”](#requestmove)

> **requestMove**: (`placement`, `destination`, `options`) => [`GameboardMovementRequestResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementrequestresult/)

Request movement to a destination.

##### Parameters

[Section titled “Parameters”](#parameters-60)

###### placement

[Section titled “placement”](#placement-7)

`string` | `Entity`

###### destination

[Section titled “destination”](#destination)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

###### options?

[Section titled “options?”](#options-51)

[`GameboardMovementPathRequestOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementpathrequestoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-62)

[`GameboardMovementRequestResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementrequestresult/)

#### resetBudget

[Section titled “resetBudget”](#resetbudget)

> **resetBudget**: (`placement?`, `options`) => readonly `Entity`\[]

Reset movement budget for one or all movement agents.

##### Parameters

[Section titled “Parameters”](#parameters-61)

###### placement?

[Section titled “placement?”](#placement-8)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-52)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-63)

readonly `Entity`\[]

#### runSystem

[Section titled “runSystem”](#runsystem)

> **runSystem**: (`options`) => [`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)\[]

Advance all active movement agents.

##### Parameters

[Section titled “Parameters”](#parameters-62)

###### options?

[Section titled “options?”](#options-53)

[`AdvanceGameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardmovementoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-64)

[`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)\[]

#### setAgent

[Section titled “setAgent”](#setagent)

> **setAgent**: (`placement`, `options`) => `Entity`

Add or update a movement agent on a placement.

##### Parameters

[Section titled “Parameters”](#parameters-63)

###### placement

[Section titled “placement”](#placement-9)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-54)

[`SetGameboardMovementAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardmovementagentoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-65)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-36)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`movement`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#movement)

***

### movePlacement

[Section titled “movePlacement”](#moveplacement-1)

> **movePlacement**: (`placement`, `to`, `options?`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:394](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L394)

Move one placement to a new tile or coordinate-like target.

Use this for actor movement, build previews, temporary markers, and gameplay props that should remain in the same Koota entity.

#### Parameters

[Section titled “Parameters”](#parameters-64)

##### placement

[Section titled “placement”](#placement-10)

`string` | `Entity`

##### to

[Section titled “to”](#to-3)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### options?

[Section titled “options?”](#options-55)

`Omit`<[`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/), `"at"`>

#### Returns

[Section titled “Returns”](#returns-66)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-37)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`movePlacement`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#moveplacement)

***

### patrol

[Section titled “patrol”](#patrol)

> `readonly` **patrol**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:314](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L314)

Patrol actions.

#### advance

[Section titled “advance”](#advance-1)

> **advance**: (`placement`, `options`) => [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)

Advance one patrol agent.

##### Parameters

[Section titled “Parameters”](#parameters-65)

###### placement

[Section titled “placement”](#placement-11)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-56)

[`AdvanceGameboardPatrolOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardpatroloptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-67)

[`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)

#### clear

[Section titled “clear”](#clear-2)

> **clear**: (`placement`) => `Entity`

Remove patrol traits from a placement.

##### Parameters

[Section titled “Parameters”](#parameters-66)

###### placement

[Section titled “placement”](#placement-12)

`string` | `Entity`

##### Returns

[Section titled “Returns”](#returns-68)

`Entity`

#### read

[Section titled “read”](#read-1)

> **read**: () => [`GameboardPatrolSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/)\[]

Read all patrol snapshots.

##### Returns

[Section titled “Returns”](#returns-69)

[`GameboardPatrolSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/)\[]

#### run

[Section titled “run”](#run)

> **run**: (`options`) => [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)\[]

Advance every patrol agent in the world.

##### Parameters

[Section titled “Parameters”](#parameters-67)

###### options?

[Section titled “options?”](#options-57)

[`AdvanceGameboardPatrolOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardpatroloptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-70)

[`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)\[]

#### set

[Section titled “set”](#set)

> **set**: (`placement`, `options`) => `Entity`

Attach or replace a patrol agent.

##### Parameters

[Section titled “Parameters”](#parameters-68)

###### placement

[Section titled “placement”](#placement-13)

`string` | `Entity`

###### options

[Section titled “options”](#options-58)

[`SetGameboardPatrolAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardpatrolagentoptions/)

##### Returns

[Section titled “Returns”](#returns-71)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-38)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`patrol`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#patrol)

***

### plan

[Section titled “plan”](#plan-3)

> **plan**: () => [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:324](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L324)

Project the live world to a renderable plan.

#### Returns

[Section titled “Returns”](#returns-72)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-39)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`plan`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#plan)

***

### planActorTargetCommand

[Section titled “planActorTargetCommand”](#planactortargetcommand)

> **planActorTargetCommand**: (`options`) => [`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:578](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L578)

Plan a command against the selected actor target.

#### Parameters

[Section titled “Parameters”](#parameters-69)

##### options

[Section titled “options”](#options-59)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

#### Returns

[Section titled “Returns”](#returns-73)

[`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-40)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`planActorTargetCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#planactortargetcommand)

***

### planCommand

[Section titled “planCommand”](#plancommand)

> **planCommand**: (`target`, `options?`) => [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:573](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L573)

Plan a command from a renderer or gameplay target.

#### Parameters

[Section titled “Parameters”](#parameters-70)

##### target

[Section titled “target”](#target-4)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

##### options?

[Section titled “options?”](#options-60)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/)

#### Returns

[Section titled “Returns”](#returns-74)

[`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-41)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`planCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#plancommand)

***

### planPatrolRoute

[Section titled “planPatrolRoute”](#planpatrolroute)

> **planPatrolRoute**: (`options`) => `GameboardPatrolRoutePlan`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:435](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L435)

Plan one patrol route from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-71)

##### options

[Section titled “options”](#options-61)

`GameboardPatrolRouteOptions`

#### Returns

[Section titled “Returns”](#returns-75)

`GameboardPatrolRoutePlan`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-42)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`planPatrolRoute`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#planpatrolroute)

***

### planPatrolRoutes

[Section titled “planPatrolRoutes”](#planpatrolroutes)

> **planPatrolRoutes**: (`options`) => `GameboardPatrolRouteSet`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:437](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L437)

Plan a patrol route set from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-72)

##### options

[Section titled “options”](#options-62)

`GameboardPatrolRouteSetOptions`

#### Returns

[Section titled “Returns”](#returns-76)

`GameboardPatrolRouteSet`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-43)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`planPatrolRoutes`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#planpatrolroutes)

***

### planSpawnGroups

[Section titled “planSpawnGroups”](#planspawngroups)

> **planSpawnGroups**: (`options`) => `GameboardSpawnGroupPlan`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:433](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L433)

Plan spawn groups from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-73)

##### options

[Section titled “options”](#options-63)

`GameboardSpawnGroupOptions`

#### Returns

[Section titled “Returns”](#returns-77)

`GameboardSpawnGroupPlan`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-44)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`planSpawnGroups`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#planspawngroups)

***

### previewCommand

[Section titled “previewCommand”](#previewcommand)

> **previewCommand**: (`commandOrTarget`, `options?`) => [`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:582](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L582)

Preview command execution without mutating state.

#### Parameters

[Section titled “Parameters”](#parameters-74)

##### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-5)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

##### options?

[Section titled “options?”](#options-64)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/)

#### Returns

[Section titled “Returns”](#returns-78)

[`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-45)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`previewCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#previewcommand)

***

### quests

[Section titled “quests”](#quests)

> `readonly` **quests**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:316](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L316)

Quest actions.

#### advance

[Section titled “advance”](#advance-2)

> **advance**: (`quest`, `options`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

Advance one quest entity.

##### Parameters

[Section titled “Parameters”](#parameters-75)

###### quest

[Section titled “quest”](#quest-2)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-65)

[`AdvanceGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardquestoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-79)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

#### advanceAll

[Section titled “advanceAll”](#advanceall)

> **advanceAll**: (`options`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Advance every quest entity.

##### Parameters

[Section titled “Parameters”](#parameters-76)

###### options?

[Section titled “options?”](#options-66)

[`AdvanceGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardquestoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-80)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

#### find

[Section titled “find”](#find)

> **find**: (`quest`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/) | `undefined`

Find one quest snapshot.

##### Parameters

[Section titled “Parameters”](#parameters-77)

###### quest

[Section titled “quest”](#quest-3)

`string` | `Entity`

##### Returns

[Section titled “Returns”](#returns-81)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/) | `undefined`

#### read

[Section titled “read”](#read-2)

> **read**: () => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Read all quest snapshots.

##### Returns

[Section titled “Returns”](#returns-82)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

#### spawn

[Section titled “spawn”](#spawn-1)

> **spawn**: (`definition`, `options`) => `Entity`

Spawn a quest entity.

##### Parameters

[Section titled “Parameters”](#parameters-78)

###### definition

[Section titled “definition”](#definition)

[`GameboardQuestDefinition`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestdefinition/)

###### options?

[Section titled “options?”](#options-67)

[`SpawnGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardquestoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-83)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-46)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`quests`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#quests)

***

### readActors

[Section titled “readActors”](#readactors)

> **readActors**: () => [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:537](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L537)

Read all registered actors joined with their placement and tile records.

#### Returns

[Section titled “Returns”](#returns-84)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-47)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`readActors`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#readactors)

***

### readActorsForTile

[Section titled “readActorsForTile”](#readactorsfortile)

> **readActorsForTile**: (`coordinates`) => [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:544](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L544)

Read registered actors whose placement origin is one tile.

Use this for hover cards, collision probes, encounter checks, and external ECS sync when a game needs actor semantics instead of raw placements.

#### Parameters

[Section titled “Parameters”](#parameters-79)

##### coordinates

[Section titled “coordinates”](#coordinates-2)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns-85)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-48)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`readActorsForTile`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#readactorsfortile)

***

### readPlacementOccupancy

[Section titled “readPlacementOccupancy”](#readplacementoccupancy)

> **readPlacementOccupancy**: () => [`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:351](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L351)

Read every placement footprint currently reserving or blocking tiles.

The returned records include origin and occupied tile metadata, so UI and pathfinding bridges can reason about multi-hex structures and blockers.

#### Returns

[Section titled “Returns”](#returns-86)

[`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-49)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`readPlacementOccupancy`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#readplacementoccupancy)

***

### readPlacementOccupancyForTile

[Section titled “readPlacementOccupancyForTile”](#readplacementoccupancyfortile)

> **readPlacementOccupancyForTile**: (`coordinates`) => [`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:358](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L358)

Read occupancy records for one tile.

Prefer this over filtering `readPlacementOccupancy()` in UI panels, collision probes, and external ECS bridges that only need one hex.

#### Parameters

[Section titled “Parameters”](#parameters-80)

##### coordinates

[Section titled “coordinates”](#coordinates-3)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns-87)

[`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-50)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`readPlacementOccupancyForTile`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#readplacementoccupancyfortile)

***

### readPlacements

[Section titled “readPlacements”](#readplacements)

> **readPlacements**: () => `object`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:337](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L337)

Read serializable placement records from live state.

Use this for save data, editor panels, renderer diffing, and external ECS mirrors that do not need raw Koota relation stores.

#### Returns

[Section titled “Returns”](#returns-88)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-51)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`readPlacements`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#readplacements)

***

### readPlacementsForTile

[Section titled “readPlacementsForTile”](#readplacementsfortile)

> **readPlacementsForTile**: (`coordinates`) => `object`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:344](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L344)

Read serializable placement records that occupy one tile.

This includes placements whose multi-tile footprint covers the tile, not only placements whose canonical origin is the tile.

#### Parameters

[Section titled “Parameters”](#parameters-81)

##### coordinates

[Section titled “coordinates”](#coordinates-4)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns-89)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-52)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`readPlacementsForTile`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#readplacementsfortile)

***

### readQuests

[Section titled “readQuests”](#readquests)

> **readQuests**: () => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:564](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L564)

Read all quest snapshots from live state for HUDs, saves, and tests.

#### Returns

[Section titled “Returns”](#returns-90)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-53)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`readQuests`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#readquests)

***

### recipe

[Section titled “recipe”](#recipe)

> `readonly` **recipe**: [`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:656](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L656)

Source recipe used to create the runtime.

***

### recipeLayoutArchetypes?

[Section titled “recipeLayoutArchetypes?”](#recipelayoutarchetypes)

> `readonly` `optional` **recipeLayoutArchetypes?**: `Readonly`<`Record`<`string`, [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)>>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:658](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L658)

Layout archetypes declared by the recipe.

***

### recipePieceRegistry?

[Section titled “recipePieceRegistry?”](#recipepieceregistry)

> `readonly` `optional` **recipePieceRegistry?**: [`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:660](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L660)

Piece registry declared by the recipe.

***

### registerActor

[Section titled “registerActor”](#registeractor)

> **registerActor**: (`placement`, `options`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:528](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L528)

Attach actor state to an existing placement.

Register existing placements when a neutral prop, marker, structure, or externally declared piece becomes selectable, interactive, hostile, or quest-addressable after startup.

#### Parameters

[Section titled “Parameters”](#parameters-82)

##### placement

[Section titled “placement”](#placement-14)

`string` | `Entity`

##### options

[Section titled “options”](#options-68)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/)

#### Returns

[Section titled “Returns”](#returns-91)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-54)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`registerActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#registeractor)

***

### removePlacement

[Section titled “removePlacement”](#removeplacement-1)

> **removePlacement**: (`placement`) => `boolean`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:404](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L404)

Remove one placement entity and its placement relations from the live world.

Returns `false` when the entity or placement id cannot be found.

#### Parameters

[Section titled “Parameters”](#parameters-83)

##### placement

[Section titled “placement”](#placement-15)

`string` | `Entity`

#### Returns

[Section titled “Returns”](#returns-92)

`boolean`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-55)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`removePlacement`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#removeplacement)

***

### selectActors

[Section titled “selectActors”](#selectactors)

> **selectActors**: (`options?`) => [`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:416](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L416)

Select actors from live state using actor-aware filters.

#### Parameters

[Section titled “Parameters”](#parameters-84)

##### options?

[Section titled “options?”](#options-69)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/)

#### Returns

[Section titled “Returns”](#returns-93)

[`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-56)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`selectActors`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#selectactors)

***

### selectPieces

[Section titled “selectPieces”](#selectpieces)

> **selectPieces**: (`registry`, `selection?`) => [`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:482](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L482)

Select declarations from a custom piece registry.

#### Parameters

[Section titled “Parameters”](#parameters-85)

##### registry

[Section titled “registry”](#registry-5)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### selection?

[Section titled “selection?”](#selection)

[`GameboardPieceRegistrySelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryselection/)

#### Returns

[Section titled “Returns”](#returns-94)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-57)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`selectPieces`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#selectpieces)

***

### selectSpawnLocations

[Section titled “selectSpawnLocations”](#selectspawnlocations)

> **selectSpawnLocations**: (`options`) => [`SpawnLocation`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocation/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:431](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L431)

Select deterministic spawn locations from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-86)

##### options

[Section titled “options”](#options-70)

`GameboardSpawnLocationOptions`

#### Returns

[Section titled “Returns”](#returns-95)

[`SpawnLocation`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocation/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-58)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`selectSpawnLocations`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#selectspawnlocations)

***

### snapshot

[Section titled “snapshot”](#snapshot)

> **snapshot**: (`options?`) => [`GameboardRuntimeSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimesnapshot/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:330](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L330)

Read a serializable runtime snapshot.

#### Parameters

[Section titled “Parameters”](#parameters-87)

##### options?

[Section titled “options?”](#options-71)

[`GameboardRuntimeSnapshotOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimesnapshotoptions/)

#### Returns

[Section titled “Returns”](#returns-96)

[`GameboardRuntimeSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimesnapshot/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-59)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`snapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#snapshot)

***

### spawnActor

[Section titled “spawnActor”](#spawnactor)

> **spawnActor**: (`options`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:520](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L520)

Spawn an actor-backed placement.

#### Parameters

[Section titled “Parameters”](#parameters-88)

##### options

[Section titled “options”](#options-72)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/)

#### Returns

[Section titled “Returns”](#returns-97)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-60)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`spawnActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#spawnactor)

***

### spawnLayoutFill

[Section titled “spawnLayoutFill”](#spawnlayoutfill)

> **spawnLayoutFill**: (`options`) => `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:455](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L455)

Spawn a generated layout fill into the live world.

#### Parameters

[Section titled “Parameters”](#parameters-89)

##### options

[Section titled “options”](#options-73)

[`GameboardLayoutFillOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfilloptions/)

#### Returns

[Section titled “Returns”](#returns-98)

`Entity`\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-61)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`spawnLayoutFill`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#spawnlayoutfill)

***

### spawnLayoutPlacements

[Section titled “spawnLayoutPlacements”](#spawnlayoutplacements)

> **spawnLayoutPlacements**: (`options`) => `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:453](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L453)

Spawn explicit layout placements into the live world.

#### Parameters

[Section titled “Parameters”](#parameters-90)

##### options

[Section titled “options”](#options-74)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-99)

`Entity`\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-62)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`spawnLayoutPlacements`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#spawnlayoutplacements)

***

### spawnPiece

[Section titled “spawnPiece”](#spawnpiece)

> **spawnPiece**: (`piece`, `options?`) => `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:472](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L472)

Spawn one declared piece into the live world.

#### Parameters

[Section titled “Parameters”](#parameters-91)

##### piece

[Section titled “piece”](#piece-3)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

##### options?

[Section titled “options?”](#options-75)

[`GameboardPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-100)

`Entity`\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-63)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`spawnPiece`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#spawnpiece)

***

### spawnPieceFills

[Section titled “spawnPieceFills”](#spawnpiecefills)

> **spawnPieceFills**: (`registry`, `fills`, `options?`) => `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:509](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L509)

Spawn generated piece fills into the live world.

#### Parameters

[Section titled “Parameters”](#parameters-92)

##### registry

[Section titled “registry”](#registry-6)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### fills

[Section titled “fills”](#fills-2)

readonly [`SeededGameboardPieceFillOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefilloptions/)\[]

##### options?

[Section titled “options?”](#options-76)

[`InspectSeededGameboardPieceFillsOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectseededgameboardpiecefillsoptions/)

#### Returns

[Section titled “Returns”](#returns-101)

`Entity`\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-64)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`spawnPieceFills`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#spawnpiecefills)

***

### spawnPlacement

[Section titled “spawnPlacement”](#spawnplacement-1)

> **spawnPlacement**: (`options`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:376](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L376)

Spawn one renderable placement into the live world.

Pass `occupancyGuard: true` when the spawn should fail instead of overlapping an existing blocker or missing footprint tile.

#### Parameters

[Section titled “Parameters”](#parameters-93)

##### options

[Section titled “options”](#options-77)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-102)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-65)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`spawnPlacement`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#spawnplacement)

***

### spawnQuest

[Section titled “spawnQuest”](#spawnquest)

> **spawnQuest**: (`definition`, `options?`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:557](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L557)

Spawn a quest definition into the live world.

Quest objectives can reference actor ids, placement ids, and tile keys, so scenario and runtime-created quests use the same progression surface.

#### Parameters

[Section titled “Parameters”](#parameters-94)

##### definition

[Section titled “definition”](#definition-1)

[`GameboardQuestDefinition`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestdefinition/)

##### options?

[Section titled “options?”](#options-78)

[`SpawnGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardquestoptions/)

#### Returns

[Section titled “Returns”](#returns-103)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-66)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`spawnQuest`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#spawnquest)

***

### summarizePlan

[Section titled “summarizePlan”](#summarizeplan)

> **summarizePlan**: (`options?`) => [`GameboardPlanSummary`](/declarative-hex-worlds/reference/index/interfaces/gameboardplansummary/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:326](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L326)

Summarize the live projected plan for editor, diagnostics, and bridge code.

#### Parameters

[Section titled “Parameters”](#parameters-95)

##### options?

[Section titled “options?”](#options-79)

[`SummarizeGameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/summarizegameboardplanoptions/)

#### Returns

[Section titled “Returns”](#returns-104)

[`GameboardPlanSummary`](/declarative-hex-worlds/reference/index/interfaces/gameboardplansummary/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-67)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`summarizePlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#summarizeplan)

***

### systems

[Section titled “systems”](#systems)

> `readonly` **systems**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:320](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L320)

System dispatch/tick actions.

#### dispatchActorTargetCommand

[Section titled “dispatchActorTargetCommand”](#dispatchactortargetcommand-1)

> **dispatchActorTargetCommand**: (`options`, `commandOptions`) => [`DispatchGameboardActorTargetCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardactortargetcommandresult/)

Select an actor target, then execute its planned command.

##### Parameters

[Section titled “Parameters”](#parameters-96)

###### options

[Section titled “options”](#options-80)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

###### commandOptions?

[Section titled “commandOptions?”](#commandoptions-1)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-105)

[`DispatchGameboardActorTargetCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardactortargetcommandresult/)

#### dispatchCommand

[Section titled “dispatchCommand”](#dispatchcommand-1)

> **dispatchCommand**: (`commandOrTarget`, `options`) => [`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

Execute one command and emit dispatch event records.

##### Parameters

[Section titled “Parameters”](#parameters-97)

###### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-6)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

###### options?

[Section titled “options?”](#options-81)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-106)

[`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

#### interact

[Section titled “interact”](#interact-1)

> **interact**: (`commandOrTarget`, `options`) => [`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/)

Dispatch a command and optionally tick systems.

##### Parameters

[Section titled “Parameters”](#parameters-98)

###### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-7)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

###### options?

[Section titled “options?”](#options-82)

[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-107)

[`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/)

#### interactActorTarget

[Section titled “interactActorTarget”](#interactactortarget-1)

> **interactActorTarget**: (`options`, `interactionOptions`) => [`RunGameboardActorTargetInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardactortargetinteractionresult/)

Target an actor, dispatch the command, and optionally tick systems.

##### Parameters

[Section titled “Parameters”](#parameters-99)

###### options

[Section titled “options”](#options-83)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

###### interactionOptions?

[Section titled “interactionOptions?”](#interactionoptions-1)

[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-108)

[`RunGameboardActorTargetInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardactortargetinteractionresult/)

#### run

[Section titled “run”](#run-1)

> **run**: (`options`) => [`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

Run enabled patrol, movement, and quest systems for one tick.

##### Parameters

[Section titled “Parameters”](#parameters-100)

###### options?

[Section titled “options?”](#options-84)

[`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-109)

[`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-68)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`systems`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#systems)

***

### tick

[Section titled “tick”](#tick)

> **tick**: (`options?`) => [`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:612](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L612)

Run enabled systems for one game-loop tick.

#### Parameters

[Section titled “Parameters”](#parameters-101)

##### options?

[Section titled “options?”](#options-85)

[`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

#### Returns

[Section titled “Returns”](#returns-110)

[`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-69)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`tick`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#tick)

***

### updateActor

[Section titled “updateActor”](#updateactor)

> **updateActor**: (`actor`, `options`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:533](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L533)

Update actor state while preserving omitted fields and placement binding.

#### Parameters

[Section titled “Parameters”](#parameters-102)

##### actor

[Section titled “actor”](#actor-6)

`string` | `Entity`

##### options

[Section titled “options”](#options-86)

[`UpdateGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardactoroptions/)

#### Returns

[Section titled “Returns”](#returns-111)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-70)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`updateActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#updateactor)

***

### updatePlacement

[Section titled “updatePlacement”](#updateplacement-1)

> **updatePlacement**: (`placement`, `options`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:384](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L384)

Update one placement in the live world while preserving omitted fields.

The helper refreshes placement classification and footprint relations when fields such as coordinates, kind, layer, footprint, tags, or blocking behavior change.

#### Parameters

[Section titled “Parameters”](#parameters-103)

##### placement

[Section titled “placement”](#placement-16)

`string` | `Entity`

##### options

[Section titled “options”](#options-87)

[`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-112)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-71)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`updatePlacement`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#updateplacement)

***

### validationPlan

[Section titled “validationPlan”](#validationplan)

> **validationPlan**: () => [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:328](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L328)

Project the live world to a plan shape suitable for validation.

#### Returns

[Section titled “Returns”](#returns-113)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-72)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`validationPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#validationplan)

***

### world

[Section titled “world”](#world)

> `readonly` **world**: `World`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:306](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L306)

Bound Koota world.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-73)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`world`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#world)

# GameboardRuntime

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:304](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L304)

Bound gameboard facade for one live board instance.

The facade keeps the raw Koota world and action bundles available, but adds game-oriented reads and mutations that project the live board before navigation, layout, piece-fill, scenario, and interop operations. Prefer this object at scene boundaries, React providers, integration tests, and external ECS bridges when the board is actively changing during play.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`GameboardScenarioGameRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariogameruntime/)
* [`GameboardRecipeGameRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardrecipegameruntime/)

## Properties

[Section titled “Properties”](#properties)

### actions

[Section titled “actions”](#actions)

> `readonly` **actions**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:308](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L308)

Raw board placement actions.

#### canOccupyPlacement

[Section titled “canOccupyPlacement”](#canoccupyplacement)

> **canOccupyPlacement**: (`options`) => `boolean`

Return only the boolean occupancy result for a proposed placement.

##### Parameters

[Section titled “Parameters”](#parameters)

###### options

[Section titled “options”](#options)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/)

##### Returns

[Section titled “Returns”](#returns)

`boolean`

#### clear

[Section titled “clear”](#clear)

> **clear**: () => `void`

Remove all board tile, placement, and board-state traits from the world.

##### Returns

[Section titled “Returns”](#returns-1)

`void`

#### inspectPlacementOccupancy

[Section titled “inspectPlacementOccupancy”](#inspectplacementoccupancy)

> **inspectPlacementOccupancy**: (`options`) => [`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/)

Inspect whether a proposed placement footprint can occupy its target tiles.

##### Parameters

[Section titled “Parameters”](#parameters-1)

###### options

[Section titled “options”](#options-1)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/)

##### Returns

[Section titled “Returns”](#returns-2)

[`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/)

#### loadPlan

[Section titled “loadPlan”](#loadplan)

> **loadPlan**: (`plan`) => [`GameboardEntityIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardentityindex/)

Replace the current world contents with a complete generated board plan.

##### Parameters

[Section titled “Parameters”](#parameters-2)

###### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

##### Returns

[Section titled “Returns”](#returns-3)

[`GameboardEntityIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardentityindex/)

#### movePlacement

[Section titled “movePlacement”](#moveplacement)

> **movePlacement**: (`placement`, `to`, `options`) => `Entity`

Move an existing placement to another tile while preserving unspecified state.

##### Parameters

[Section titled “Parameters”](#parameters-3)

###### placement

[Section titled “placement”](#placement)

`string` | `Entity`

###### to

[Section titled “to”](#to)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

###### options?

[Section titled “options?”](#options-2)

[`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-4)

`Entity`

#### removePlacement

[Section titled “removePlacement”](#removeplacement)

> **removePlacement**: (`placement`) => `boolean`

Remove an existing placement by entity or placement id.

##### Parameters

[Section titled “Parameters”](#parameters-4)

###### placement

[Section titled “placement”](#placement-1)

`string` | `Entity`

##### Returns

[Section titled “Returns”](#returns-5)

`boolean`

#### spawnPlacement

[Section titled “spawnPlacement”](#spawnplacement)

> **spawnPlacement**: (`options`) => `Entity`

Spawn a runtime placement into the board.

##### Parameters

[Section titled “Parameters”](#parameters-5)

###### options

[Section titled “options”](#options-3)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)

##### Returns

[Section titled “Returns”](#returns-6)

`Entity`

#### updatePlacement

[Section titled “updatePlacement”](#updateplacement)

> **updatePlacement**: (`placement`, `options`) => `Entity`

Update an existing runtime placement by entity or placement id.

##### Parameters

[Section titled “Parameters”](#parameters-6)

###### placement

[Section titled “placement”](#placement-2)

`string` | `Entity`

###### options

[Section titled “options”](#options-4)

[`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/)

##### Returns

[Section titled “Returns”](#returns-7)

`Entity`

***

### actors

[Section titled “actors”](#actors)

> `readonly` **actors**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:310](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L310)

Actor actions.

#### collision

[Section titled “collision”](#collision)

> **collision**: (`actor`, `target`, `profile`) => [`GameboardActorCollisionReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionreport/)

Inspect whether an actor can enter a target tile.

##### Parameters

[Section titled “Parameters”](#parameters-7)

###### actor

[Section titled “actor”](#actor)

`string` | `Entity` | `undefined`

###### target

[Section titled “target”](#target)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

###### profile?

[Section titled “profile?”](#profile)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/) = `{}`

##### Returns

[Section titled “Returns”](#returns-8)

[`GameboardActorCollisionReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionreport/)

#### command

[Section titled “command”](#command)

> **command**: (`target`, `options`) => [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

Plan a high-level interaction command from a target input.

##### Parameters

[Section titled “Parameters”](#parameters-8)

###### target

[Section titled “target”](#target-1)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

###### options?

[Section titled “options?”](#options-5)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-9)

[`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

#### interaction

[Section titled “interaction”](#interaction)

> **interaction**: (`target`, `options`) => [`GameboardInteractionTargetReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetreport/)

Resolve and inspect an interaction target.

##### Parameters

[Section titled “Parameters”](#parameters-9)

###### target

[Section titled “target”](#target-2)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

###### options?

[Section titled “options?”](#options-6)

[`GameboardInteractionTargetOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-10)

[`GameboardInteractionTargetReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetreport/)

#### move

[Section titled “move”](#move)

> **move**: (`actor`, `to`, `options`) => `Entity`

Move an actor to another tile.

##### Parameters

[Section titled “Parameters”](#parameters-10)

###### actor

[Section titled “actor”](#actor-1)

`string` | `Entity`

###### to

[Section titled “to”](#to-1)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

###### options?

[Section titled “options?”](#options-7)

[`MoveGameboardActorOptions`](/declarative-hex-worlds/reference/index/type-aliases/movegameboardactoroptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-11)

`Entity`

#### navigationProfile

[Section titled “navigationProfile”](#navigationprofile)

> **navigationProfile**: (`actor`, `options`) => [`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

Create an actor-aware navigation profile.

##### Parameters

[Section titled “Parameters”](#parameters-11)

###### actor

[Section titled “actor”](#actor-2)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-8)

[`GameboardActorNavigationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactornavigationoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-12)

[`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

#### neighborhood

[Section titled “neighborhood”](#neighborhood)

> **neighborhood**: (`center`, `options`) => [`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

Inspect a radius of tiles around a center.

##### Parameters

[Section titled “Parameters”](#parameters-12)

###### center

[Section titled “center”](#center)

[`GameboardNeighborhoodCenter`](/declarative-hex-worlds/reference/index/type-aliases/gameboardneighborhoodcenter/)

###### options?

[Section titled “options?”](#options-9)

[`GameboardNeighborhoodInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspectionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-13)

[`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

#### read

[Section titled “read”](#read)

> **read**: () => [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Read all registered actors.

##### Returns

[Section titled “Returns”](#returns-14)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

#### register

[Section titled “register”](#register)

> **register**: (`placement`, `options`) => `Entity`

Register an existing placement as an actor.

##### Parameters

[Section titled “Parameters”](#parameters-13)

###### placement

[Section titled “placement”](#placement-3)

`string` | `Entity`

###### options

[Section titled “options”](#options-10)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/)

##### Returns

[Section titled “Returns”](#returns-15)

`Entity`

#### select

[Section titled “select”](#select)

> **select**: (`options`) => [`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

Select actors with optional faction, team, tag, radius, and hostility filters.

##### Parameters

[Section titled “Parameters”](#parameters-14)

###### options?

[Section titled “options?”](#options-11)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-16)

[`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

#### spawn

[Section titled “spawn”](#spawn)

> **spawn**: (`options`) => `Entity`

Spawn a placement and register it as an actor.

##### Parameters

[Section titled “Parameters”](#parameters-15)

###### options

[Section titled “options”](#options-12)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/)

##### Returns

[Section titled “Returns”](#returns-17)

`Entity`

#### targets

[Section titled “targets”](#targets)

> **targets**: (`options`) => [`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/)

Select and path to candidate actor targets.

##### Parameters

[Section titled “Parameters”](#parameters-16)

###### options

[Section titled “options”](#options-13)

[`GameboardActorTargetingOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/)

##### Returns

[Section titled “Returns”](#returns-18)

[`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/)

#### tile

[Section titled “tile”](#tile)

> **tile**: (`coordinates`, `options`) => [`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

Inspect one tile from an actor/gameplay perspective.

##### Parameters

[Section titled “Parameters”](#parameters-17)

###### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

###### options?

[Section titled “options?”](#options-14)

[`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-19)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

#### update

[Section titled “update”](#update)

> **update**: (`actor`, `options`) => `Entity`

Update actor trait state while preserving omitted fields.

##### Parameters

[Section titled “Parameters”](#parameters-18)

###### actor

[Section titled “actor”](#actor-3)

`string` | `Entity`

###### options

[Section titled “options”](#options-15)

[`UpdateGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardactoroptions/)

##### Returns

[Section titled “Returns”](#returns-20)

`Entity`

***

### advanceAllQuests

[Section titled “advanceAllQuests”](#advanceallquests)

> **advanceAllQuests**: (`options?`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:571](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L571)

Advance every quest against the current live actor, placement, and tile state.

#### Parameters

[Section titled “Parameters”](#parameters-19)

##### options?

[Section titled “options?”](#options-16)

[`AdvanceGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardquestoptions/)

#### Returns

[Section titled “Returns”](#returns-21)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

***

### advanceQuest

[Section titled “advanceQuest”](#advancequest)

> **advanceQuest**: (`quest`, `options?`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:566](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L566)

Advance one quest against the current live actor, placement, and tile state.

#### Parameters

[Section titled “Parameters”](#parameters-20)

##### quest

[Section titled “quest”](#quest)

`string` | `Entity`

##### options?

[Section titled “options?”](#options-17)

[`AdvanceGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardquestoptions/)

#### Returns

[Section titled “Returns”](#returns-22)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

***

### analyzeLayoutFill

[Section titled “analyzeLayoutFill”](#analyzelayoutfill)

> **analyzeLayoutFill**: (`options`) => [`GameboardLayoutFillAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillanalysis/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:447](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L447)

Analyze seeded layout fill rules against the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-21)

##### options

[Section titled “options”](#options-18)

[`GameboardLayoutFillOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfilloptions/)

#### Returns

[Section titled “Returns”](#returns-23)

[`GameboardLayoutFillAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillanalysis/)

***

### analyzePieceFills

[Section titled “analyzePieceFills”](#analyzepiecefills)

> **analyzePieceFills**: (`registry`, `fills`, `options?`) => [`GameboardLayoutFillAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillanalysis/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:497](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L497)

Analyze generated piece fills against the current projected plan.

#### Parameters

[Section titled “Parameters”](#parameters-22)

##### registry

[Section titled “registry”](#registry)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### fills

[Section titled “fills”](#fills)

readonly [`SeededGameboardPieceFillOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefilloptions/)\[]

##### options?

[Section titled “options?”](#options-19)

[`InspectSeededGameboardPieceFillsOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectseededgameboardpiecefillsoptions/)

#### Returns

[Section titled “Returns”](#returns-24)

[`GameboardLayoutFillAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillanalysis/)

***

### analyzePieceRegistry

[Section titled “analyzePieceRegistry”](#analyzepieceregistry)

> **analyzePieceRegistry**: (`registry`, `options?`) => [`GameboardPieceRegistryAnalysis`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryanalysis/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:477](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L477)

Analyze a custom piece registry.

#### Parameters

[Section titled “Parameters”](#parameters-23)

##### registry

[Section titled “registry”](#registry-1)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### options?

[Section titled “options?”](#options-20)

[`AnalyzeGameboardPieceRegistryOptions`](/declarative-hex-worlds/reference/index/interfaces/analyzegameboardpieceregistryoptions/)

#### Returns

[Section titled “Returns”](#returns-25)

[`GameboardPieceRegistryAnalysis`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryanalysis/)

***

### canOccupyPlacement

[Section titled “canOccupyPlacement”](#canoccupyplacement-1)

> **canOccupyPlacement**: (`options`) => `boolean`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:369](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L369)

Return the boolean result from `inspectPlacementOccupancy`.

#### Parameters

[Section titled “Parameters”](#parameters-24)

##### options

[Section titled “options”](#options-21)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/)

#### Returns

[Section titled “Returns”](#returns-26)

`boolean`

***

### commands

[Section titled “commands”](#commands)

> `readonly` **commands**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:318](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L318)

Command planning/execution actions.

#### execute

[Section titled “execute”](#execute)

> **execute**: (`commandOrTarget`, `options`) => [`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

Execute a command with optional host-game handlers.

##### Parameters

[Section titled “Parameters”](#parameters-25)

###### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

###### options?

[Section titled “options?”](#options-22)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-27)

[`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

#### plan

[Section titled “plan”](#plan-1)

> **plan**: (`target`, `options`) => [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

Plan a command from a renderer or gameplay target.

##### Parameters

[Section titled “Parameters”](#parameters-26)

###### target

[Section titled “target”](#target-3)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

###### options?

[Section titled “options?”](#options-23)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-28)

[`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

#### preview

[Section titled “preview”](#preview)

> **preview**: (`commandOrTarget`, `options`) => [`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

Preview a command without mutating state.

##### Parameters

[Section titled “Parameters”](#parameters-27)

###### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-1)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

###### options?

[Section titled “options?”](#options-24)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-29)

[`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

#### targetCommand

[Section titled “targetCommand”](#targetcommand)

> **targetCommand**: (`options`) => [`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

Select an actor target and plan a command against it.

##### Parameters

[Section titled “Parameters”](#parameters-28)

###### options

[Section titled “options”](#options-25)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

##### Returns

[Section titled “Returns”](#returns-30)

[`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

***

### createInteropSnapshot

[Section titled “createInteropSnapshot”](#createinteropsnapshot)

> **createInteropSnapshot**: (`options?`) => [`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:420](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L420)

Create an ECS interop snapshot from the live runtime.

#### Parameters

[Section titled “Parameters”](#parameters-29)

##### options?

[Section titled “options?”](#options-26)

[`GameboardRuntimeInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimeinteropoptions/)

#### Returns

[Section titled “Returns”](#returns-31)

[`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

***

### createLayoutFillPlacements

[Section titled “createLayoutFillPlacements”](#createlayoutfillplacements)

> **createLayoutFillPlacements**: (`options`) => [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:449](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L449)

Create seeded layout fill placement options without mutating the live world.

#### Parameters

[Section titled “Parameters”](#parameters-30)

##### options

[Section titled “options”](#options-27)

[`GameboardLayoutFillOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfilloptions/)

#### Returns

[Section titled “Returns”](#returns-32)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

***

### createLayoutPlacements

[Section titled “createLayoutPlacements”](#createlayoutplacements)

> **createLayoutPlacements**: (`options`) => [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:443](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L443)

Create layout placement spawn options without mutating the live world.

#### Parameters

[Section titled “Parameters”](#parameters-31)

##### options

[Section titled “options”](#options-28)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-33)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

***

### createNavigation

[Section titled “createNavigation”](#createnavigation)

> **createNavigation**: (`profile?`) => [`GameboardNavigation`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigation/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:429](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L429)

Create a pathfinding/navigation facade from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-32)

##### profile?

[Section titled “profile?”](#profile-1)

[`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

#### Returns

[Section titled “Returns”](#returns-34)

[`GameboardNavigation`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigation/)

***

### createOccupancyIndex

[Section titled “createOccupancyIndex”](#createoccupancyindex)

> **createOccupancyIndex**: (`profile?`) => [`GameboardOccupancyIndex`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardoccupancyindex/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:427](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L427)

Create a navigation occupancy index from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-33)

##### profile?

[Section titled “profile?”](#profile-2)

[`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

#### Returns

[Section titled “Returns”](#returns-35)

[`GameboardOccupancyIndex`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardoccupancyindex/)

***

### createPieceFillRules

[Section titled “createPieceFillRules”](#createpiecefillrules)

> **createPieceFillRules**: (`registry`, `options?`) => [`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:487](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L487)

Create layout fill rules from selected registry pieces.

#### Parameters

[Section titled “Parameters”](#parameters-34)

##### registry

[Section titled “registry”](#registry-2)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### options?

[Section titled “options?”](#options-29)

[`GameboardPieceRegistryFillRulesOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryfillrulesoptions/)

#### Returns

[Section titled “Returns”](#returns-36)

[`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

***

### createPiecePlacementOptions

[Section titled “createPiecePlacementOptions”](#createpieceplacementoptions)

> **createPiecePlacementOptions**: (`piece`, `options?`) => [`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:457](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L457)

Convert a piece declaration to layout placement options.

#### Parameters

[Section titled “Parameters”](#parameters-35)

##### piece

[Section titled “piece”](#piece)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

##### options?

[Section titled “options?”](#options-30)

[`GameboardPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-37)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/)

***

### createPiecePlacements

[Section titled “createPiecePlacements”](#createpieceplacements)

> **createPiecePlacements**: (`piece`, `options?`) => [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:462](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L462)

Create placement options for a piece against the current projected plan.

#### Parameters

[Section titled “Parameters”](#parameters-36)

##### piece

[Section titled “piece”](#piece-1)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

##### options?

[Section titled “options?”](#options-31)

[`GameboardPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-38)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

***

### createPiecePoolFillRule

[Section titled “createPiecePoolFillRule”](#createpiecepoolfillrule)

> **createPiecePoolFillRule**: (`pieces`, `options?`) => [`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:492](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L492)

Create one pooled fill rule from a piece collection.

#### Parameters

[Section titled “Parameters”](#parameters-37)

##### pieces

[Section titled “pieces”](#pieces)

readonly [`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)\[]

##### options?

[Section titled “options?”](#options-32)

[`GameboardPieceCollectionLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiececollectionlayoutruleoptions/)

#### Returns

[Section titled “Returns”](#returns-39)

[`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)

***

### createPieceSourceUrlMap

[Section titled “createPieceSourceUrlMap”](#createpiecesourceurlmap)

> **createPieceSourceUrlMap**: (`registry`, `options?`) => `Readonly`<`Record`<`string`, `string`>>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:515](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L515)

Create an asset-id-to-URL map for local custom pieces.

#### Parameters

[Section titled “Parameters”](#parameters-38)

##### registry

[Section titled “registry”](#registry-3)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### options?

[Section titled “options?”](#options-33)

[`GameboardPieceSourceUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecesourceurloptions/)

#### Returns

[Section titled “Returns”](#returns-40)

`Readonly`<`Record`<`string`, `string`>>

***

### dispatchActorTargetCommand

[Section titled “dispatchActorTargetCommand”](#dispatchactortargetcommand)

> **dispatchActorTargetCommand**: (`options`, `commandOptions?`) => [`DispatchGameboardActorTargetCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardactortargetcommandresult/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:592](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L592)

Select an actor target and dispatch the planned command.

#### Parameters

[Section titled “Parameters”](#parameters-39)

##### options

[Section titled “options”](#options-34)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

##### commandOptions?

[Section titled “commandOptions?”](#commandoptions)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/)

#### Returns

[Section titled “Returns”](#returns-41)

[`DispatchGameboardActorTargetCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardactortargetcommandresult/)

***

### dispatchCommand

[Section titled “dispatchCommand”](#dispatchcommand)

> **dispatchCommand**: (`commandOrTarget`, `options?`) => [`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:587](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L587)

Execute a command and return dispatch events.

#### Parameters

[Section titled “Parameters”](#parameters-40)

##### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-2)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

##### options?

[Section titled “options?”](#options-35)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/)

#### Returns

[Section titled “Returns”](#returns-42)

[`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

***

### executeCommand

[Section titled “executeCommand”](#executecommand)

> **executeCommand**: (`commandOrTarget`, `options?`) => [`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:597](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L597)

Execute a command without wrapping it in system events.

#### Parameters

[Section titled “Parameters”](#parameters-41)

##### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-3)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

##### options?

[Section titled “options?”](#options-36)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/)

#### Returns

[Section titled “Returns”](#returns-43)

[`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

***

### findActor

[Section titled “findActor”](#findactor)

> **findActor**: (`actor`) => [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:535](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L535)

Find one actor by entity, placement id, or stable actor id.

#### Parameters

[Section titled “Parameters”](#parameters-42)

##### actor

[Section titled “actor”](#actor-4)

`string` | `Entity`

#### Returns

[Section titled “Returns”](#returns-44)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/) | `undefined`

***

### findQuest

[Section titled “findQuest”](#findquest)

> **findQuest**: (`quest`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:562](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L562)

Find one quest by entity or stable quest id.

#### Parameters

[Section titled “Parameters”](#parameters-43)

##### quest

[Section titled “quest”](#quest-1)

`string` | `Entity`

#### Returns

[Section titled “Returns”](#returns-45)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/) | `undefined`

***

### inspectActorTargets

[Section titled “inspectActorTargets”](#inspectactortargets)

> **inspectActorTargets**: (`options`) => [`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:418](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L418)

Select and rank actor targets with path and command planning.

#### Parameters

[Section titled “Parameters”](#parameters-44)

##### options

[Section titled “options”](#options-37)

[`GameboardActorTargetingOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/)

#### Returns

[Section titled “Returns”](#returns-46)

[`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/)

***

### inspectLayoutSites

[Section titled “inspectLayoutSites”](#inspectlayoutsites)

> **inspectLayoutSites**: (`options?`) => [`GameboardLayoutSiteInspection`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutsiteinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:439](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L439)

Inspect layout candidates and rejections against the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-45)

##### options?

[Section titled “options?”](#options-38)

[`InspectGameboardLayoutSitesOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/inspectgameboardlayoutsitesoptions/)

#### Returns

[Section titled “Returns”](#returns-47)

[`GameboardLayoutSiteInspection`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutsiteinspection/)

***

### inspectNeighborhood

[Section titled “inspectNeighborhood”](#inspectneighborhood)

> **inspectNeighborhood**: (`center`, `options?`) => [`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:411](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L411)

Inspect a radius around a tile, placement, actor, or coordinate.

#### Parameters

[Section titled “Parameters”](#parameters-46)

##### center

[Section titled “center”](#center-1)

[`GameboardNeighborhoodCenter`](/declarative-hex-worlds/reference/index/type-aliases/gameboardneighborhoodcenter/)

##### options?

[Section titled “options?”](#options-39)

[`GameboardNeighborhoodInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspectionoptions/)

#### Returns

[Section titled “Returns”](#returns-48)

[`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

***

### inspectPieceFills

[Section titled “inspectPieceFills”](#inspectpiecefills)

> **inspectPieceFills**: (`registry`, `fills`, `options?`) => [`SeededGameboardPieceFillInspection`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefillinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:503](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L503)

Inspect generated piece fills with candidate and rejection details.

#### Parameters

[Section titled “Parameters”](#parameters-47)

##### registry

[Section titled “registry”](#registry-4)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### fills

[Section titled “fills”](#fills-1)

readonly [`SeededGameboardPieceFillOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefilloptions/)\[]

##### options?

[Section titled “options?”](#options-40)

[`InspectSeededGameboardPieceFillsOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectseededgameboardpiecefillsoptions/)

#### Returns

[Section titled “Returns”](#returns-49)

[`SeededGameboardPieceFillInspection`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefillinspection/)

***

### inspectPiecePlacement

[Section titled “inspectPiecePlacement”](#inspectpieceplacement)

> **inspectPiecePlacement**: (`piece`, `options?`) => [`GameboardPiecePlacementInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:467](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L467)

Inspect where a piece can be placed against the current projected plan.

#### Parameters

[Section titled “Parameters”](#parameters-48)

##### piece

[Section titled “piece”](#piece-2)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

##### options?

[Section titled “options?”](#options-41)

[`GameboardPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-50)

[`GameboardPiecePlacementInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementinspection/)

***

### inspectPlacementOccupancy

[Section titled “inspectPlacementOccupancy”](#inspectplacementoccupancy-1)

> **inspectPlacementOccupancy**: (`options`) => [`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:365](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L365)

Inspect whether a placement footprint can occupy the current live board.

This is the preflight path for construction cursors, drag previews, unit moves, and generated fills before mutating the world.

#### Parameters

[Section titled “Parameters”](#parameters-49)

##### options

[Section titled “options”](#options-42)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/)

#### Returns

[Section titled “Returns”](#returns-51)

[`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/)

***

### inspectTile

[Section titled “inspectTile”](#inspecttile)

> **inspectTile**: (`coordinates`, `options?`) => [`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:406](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L406)

Inspect one tile, placement, actor, or coordinate in live state.

#### Parameters

[Section titled “Parameters”](#parameters-50)

##### coordinates

[Section titled “coordinates”](#coordinates-1)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### options?

[Section titled “options?”](#options-43)

[`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/)

#### Returns

[Section titled “Returns”](#returns-52)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

***

### interact

[Section titled “interact”](#interact)

> **interact**: (`commandOrTarget`, `options?`) => [`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:602](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L602)

Dispatch a command and optionally run systems.

#### Parameters

[Section titled “Parameters”](#parameters-51)

##### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-4)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

##### options?

[Section titled “options?”](#options-44)

[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/)

#### Returns

[Section titled “Returns”](#returns-53)

[`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/)

***

### interactActorTarget

[Section titled “interactActorTarget”](#interactactortarget)

> **interactActorTarget**: (`options`, `interactionOptions?`) => [`RunGameboardActorTargetInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardactortargetinteractionresult/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:607](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L607)

Target an actor, dispatch the command, and optionally run systems.

#### Parameters

[Section titled “Parameters”](#parameters-52)

##### options

[Section titled “options”](#options-45)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

##### interactionOptions?

[Section titled “interactionOptions?”](#interactionoptions)

[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/)

#### Returns

[Section titled “Returns”](#returns-54)

[`RunGameboardActorTargetInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardactortargetinteractionresult/)

***

### loadPlan

[Section titled “loadPlan”](#loadplan-1)

> **loadPlan**: (`plan`) => [`GameboardEntityIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardentityindex/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:322](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L322)

Load a plan into the bound world.

#### Parameters

[Section titled “Parameters”](#parameters-53)

##### plan

[Section titled “plan”](#plan-2)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

#### Returns

[Section titled “Returns”](#returns-55)

[`GameboardEntityIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardentityindex/)

***

### mountInterop

[Section titled “mountInterop”](#mountinterop)

> **mountInterop**: <`TEntity`>(`adapter`, `options?`) => [`GameboardEcsMountResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsmountresult/)<`TEntity`>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:422](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L422)

Mount the live runtime snapshot into another ECS/store adapter.

#### Type Parameters

[Section titled “Type Parameters”](#type-parameters)

##### TEntity

[Section titled “TEntity”](#tentity)

`TEntity`

#### Parameters

[Section titled “Parameters”](#parameters-54)

##### adapter

[Section titled “adapter”](#adapter)

[`GameboardEcsAdapter`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsadapter/)<`TEntity`>

##### options?

[Section titled “options?”](#options-46)

[`GameboardRuntimeInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimeinteropoptions/)

#### Returns

[Section titled “Returns”](#returns-56)

[`GameboardEcsMountResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsmountresult/)<`TEntity`>

***

### moveActor

[Section titled “moveActor”](#moveactor)

> **moveActor**: (`actor`, `to`, `options?`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:546](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L546)

Move an actor-backed placement by actor id or entity.

#### Parameters

[Section titled “Parameters”](#parameters-55)

##### actor

[Section titled “actor”](#actor-5)

`string` | `Entity`

##### to

[Section titled “to”](#to-2)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### options?

[Section titled “options?”](#options-47)

[`MoveGameboardActorOptions`](/declarative-hex-worlds/reference/index/type-aliases/movegameboardactoroptions/)

#### Returns

[Section titled “Returns”](#returns-57)

`Entity`

***

### movement

[Section titled “movement”](#movement)

> `readonly` **movement**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:312](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L312)

Movement actions.

#### advance

[Section titled “advance”](#advance)

> **advance**: (`placement`, `options`) => [`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)

Advance one placement along its requested path.

##### Parameters

[Section titled “Parameters”](#parameters-56)

###### placement

[Section titled “placement”](#placement-4)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-48)

[`AdvanceGameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardmovementoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-58)

[`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)

#### clear

[Section titled “clear”](#clear-1)

> **clear**: (`placement`) => `Entity`

Clear active movement path state for a placement.

##### Parameters

[Section titled “Parameters”](#parameters-57)

###### placement

[Section titled “placement”](#placement-5)

`string` | `Entity`

##### Returns

[Section titled “Returns”](#returns-59)

`Entity`

#### reachable

[Section titled “reachable”](#reachable)

> **reachable**: (`placement`, `options`) => [`GameboardReachableTile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardreachabletile/)\[]

Return tiles reachable by one movement agent.

##### Parameters

[Section titled “Parameters”](#parameters-58)

###### placement

[Section titled “placement”](#placement-6)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-49)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-60)

[`GameboardReachableTile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardreachabletile/)\[]

#### requestMove

[Section titled “requestMove”](#requestmove)

> **requestMove**: (`placement`, `destination`, `options`) => [`GameboardMovementRequestResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementrequestresult/)

Request movement to a destination.

##### Parameters

[Section titled “Parameters”](#parameters-59)

###### placement

[Section titled “placement”](#placement-7)

`string` | `Entity`

###### destination

[Section titled “destination”](#destination)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

###### options?

[Section titled “options?”](#options-50)

[`GameboardMovementPathRequestOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementpathrequestoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-61)

[`GameboardMovementRequestResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementrequestresult/)

#### resetBudget

[Section titled “resetBudget”](#resetbudget)

> **resetBudget**: (`placement?`, `options`) => readonly `Entity`\[]

Reset movement budget for one or all movement agents.

##### Parameters

[Section titled “Parameters”](#parameters-60)

###### placement?

[Section titled “placement?”](#placement-8)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-51)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-62)

readonly `Entity`\[]

#### runSystem

[Section titled “runSystem”](#runsystem)

> **runSystem**: (`options`) => [`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)\[]

Advance all active movement agents.

##### Parameters

[Section titled “Parameters”](#parameters-61)

###### options?

[Section titled “options?”](#options-52)

[`AdvanceGameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardmovementoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-63)

[`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)\[]

#### setAgent

[Section titled “setAgent”](#setagent)

> **setAgent**: (`placement`, `options`) => `Entity`

Add or update a movement agent on a placement.

##### Parameters

[Section titled “Parameters”](#parameters-62)

###### placement

[Section titled “placement”](#placement-9)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-53)

[`SetGameboardMovementAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardmovementagentoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-64)

`Entity`

***

### movePlacement

[Section titled “movePlacement”](#moveplacement-1)

> **movePlacement**: (`placement`, `to`, `options?`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:394](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L394)

Move one placement to a new tile or coordinate-like target.

Use this for actor movement, build previews, temporary markers, and gameplay props that should remain in the same Koota entity.

#### Parameters

[Section titled “Parameters”](#parameters-63)

##### placement

[Section titled “placement”](#placement-10)

`string` | `Entity`

##### to

[Section titled “to”](#to-3)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### options?

[Section titled “options?”](#options-54)

`Omit`<[`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/), `"at"`>

#### Returns

[Section titled “Returns”](#returns-65)

`Entity`

***

### patrol

[Section titled “patrol”](#patrol)

> `readonly` **patrol**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:314](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L314)

Patrol actions.

#### advance

[Section titled “advance”](#advance-1)

> **advance**: (`placement`, `options`) => [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)

Advance one patrol agent.

##### Parameters

[Section titled “Parameters”](#parameters-64)

###### placement

[Section titled “placement”](#placement-11)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-55)

[`AdvanceGameboardPatrolOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardpatroloptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-66)

[`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)

#### clear

[Section titled “clear”](#clear-2)

> **clear**: (`placement`) => `Entity`

Remove patrol traits from a placement.

##### Parameters

[Section titled “Parameters”](#parameters-65)

###### placement

[Section titled “placement”](#placement-12)

`string` | `Entity`

##### Returns

[Section titled “Returns”](#returns-67)

`Entity`

#### read

[Section titled “read”](#read-1)

> **read**: () => [`GameboardPatrolSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/)\[]

Read all patrol snapshots.

##### Returns

[Section titled “Returns”](#returns-68)

[`GameboardPatrolSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/)\[]

#### run

[Section titled “run”](#run)

> **run**: (`options`) => [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)\[]

Advance every patrol agent in the world.

##### Parameters

[Section titled “Parameters”](#parameters-66)

###### options?

[Section titled “options?”](#options-56)

[`AdvanceGameboardPatrolOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardpatroloptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-69)

[`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)\[]

#### set

[Section titled “set”](#set)

> **set**: (`placement`, `options`) => `Entity`

Attach or replace a patrol agent.

##### Parameters

[Section titled “Parameters”](#parameters-67)

###### placement

[Section titled “placement”](#placement-13)

`string` | `Entity`

###### options

[Section titled “options”](#options-57)

[`SetGameboardPatrolAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardpatrolagentoptions/)

##### Returns

[Section titled “Returns”](#returns-70)

`Entity`

***

### plan

[Section titled “plan”](#plan-3)

> **plan**: () => [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:324](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L324)

Project the live world to a renderable plan.

#### Returns

[Section titled “Returns”](#returns-71)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

***

### planActorTargetCommand

[Section titled “planActorTargetCommand”](#planactortargetcommand)

> **planActorTargetCommand**: (`options`) => [`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:578](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L578)

Plan a command against the selected actor target.

#### Parameters

[Section titled “Parameters”](#parameters-68)

##### options

[Section titled “options”](#options-58)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

#### Returns

[Section titled “Returns”](#returns-72)

[`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

***

### planCommand

[Section titled “planCommand”](#plancommand)

> **planCommand**: (`target`, `options?`) => [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:573](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L573)

Plan a command from a renderer or gameplay target.

#### Parameters

[Section titled “Parameters”](#parameters-69)

##### target

[Section titled “target”](#target-4)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

##### options?

[Section titled “options?”](#options-59)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/)

#### Returns

[Section titled “Returns”](#returns-73)

[`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

***

### planPatrolRoute

[Section titled “planPatrolRoute”](#planpatrolroute)

> **planPatrolRoute**: (`options`) => `GameboardPatrolRoutePlan`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:435](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L435)

Plan one patrol route from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-70)

##### options

[Section titled “options”](#options-60)

`GameboardPatrolRouteOptions`

#### Returns

[Section titled “Returns”](#returns-74)

`GameboardPatrolRoutePlan`

***

### planPatrolRoutes

[Section titled “planPatrolRoutes”](#planpatrolroutes)

> **planPatrolRoutes**: (`options`) => `GameboardPatrolRouteSet`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:437](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L437)

Plan a patrol route set from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-71)

##### options

[Section titled “options”](#options-61)

`GameboardPatrolRouteSetOptions`

#### Returns

[Section titled “Returns”](#returns-75)

`GameboardPatrolRouteSet`

***

### planSpawnGroups

[Section titled “planSpawnGroups”](#planspawngroups)

> **planSpawnGroups**: (`options`) => `GameboardSpawnGroupPlan`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:433](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L433)

Plan spawn groups from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-72)

##### options

[Section titled “options”](#options-62)

`GameboardSpawnGroupOptions`

#### Returns

[Section titled “Returns”](#returns-76)

`GameboardSpawnGroupPlan`

***

### previewCommand

[Section titled “previewCommand”](#previewcommand)

> **previewCommand**: (`commandOrTarget`, `options?`) => [`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:582](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L582)

Preview command execution without mutating state.

#### Parameters

[Section titled “Parameters”](#parameters-73)

##### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-5)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

##### options?

[Section titled “options?”](#options-63)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/)

#### Returns

[Section titled “Returns”](#returns-77)

[`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

***

### quests

[Section titled “quests”](#quests)

> `readonly` **quests**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:316](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L316)

Quest actions.

#### advance

[Section titled “advance”](#advance-2)

> **advance**: (`quest`, `options`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

Advance one quest entity.

##### Parameters

[Section titled “Parameters”](#parameters-74)

###### quest

[Section titled “quest”](#quest-2)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-64)

[`AdvanceGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardquestoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-78)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

#### advanceAll

[Section titled “advanceAll”](#advanceall)

> **advanceAll**: (`options`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Advance every quest entity.

##### Parameters

[Section titled “Parameters”](#parameters-75)

###### options?

[Section titled “options?”](#options-65)

[`AdvanceGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardquestoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-79)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

#### find

[Section titled “find”](#find)

> **find**: (`quest`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/) | `undefined`

Find one quest snapshot.

##### Parameters

[Section titled “Parameters”](#parameters-76)

###### quest

[Section titled “quest”](#quest-3)

`string` | `Entity`

##### Returns

[Section titled “Returns”](#returns-80)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/) | `undefined`

#### read

[Section titled “read”](#read-2)

> **read**: () => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Read all quest snapshots.

##### Returns

[Section titled “Returns”](#returns-81)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

#### spawn

[Section titled “spawn”](#spawn-1)

> **spawn**: (`definition`, `options`) => `Entity`

Spawn a quest entity.

##### Parameters

[Section titled “Parameters”](#parameters-77)

###### definition

[Section titled “definition”](#definition)

[`GameboardQuestDefinition`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestdefinition/)

###### options?

[Section titled “options?”](#options-66)

[`SpawnGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardquestoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-82)

`Entity`

***

### readActors

[Section titled “readActors”](#readactors)

> **readActors**: () => [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:537](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L537)

Read all registered actors joined with their placement and tile records.

#### Returns

[Section titled “Returns”](#returns-83)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

***

### readActorsForTile

[Section titled “readActorsForTile”](#readactorsfortile)

> **readActorsForTile**: (`coordinates`) => [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:544](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L544)

Read registered actors whose placement origin is one tile.

Use this for hover cards, collision probes, encounter checks, and external ECS sync when a game needs actor semantics instead of raw placements.

#### Parameters

[Section titled “Parameters”](#parameters-78)

##### coordinates

[Section titled “coordinates”](#coordinates-2)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns-84)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

***

### readPlacementOccupancy

[Section titled “readPlacementOccupancy”](#readplacementoccupancy)

> **readPlacementOccupancy**: () => [`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:351](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L351)

Read every placement footprint currently reserving or blocking tiles.

The returned records include origin and occupied tile metadata, so UI and pathfinding bridges can reason about multi-hex structures and blockers.

#### Returns

[Section titled “Returns”](#returns-85)

[`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

***

### readPlacementOccupancyForTile

[Section titled “readPlacementOccupancyForTile”](#readplacementoccupancyfortile)

> **readPlacementOccupancyForTile**: (`coordinates`) => [`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:358](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L358)

Read occupancy records for one tile.

Prefer this over filtering `readPlacementOccupancy()` in UI panels, collision probes, and external ECS bridges that only need one hex.

#### Parameters

[Section titled “Parameters”](#parameters-79)

##### coordinates

[Section titled “coordinates”](#coordinates-3)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns-86)

[`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

***

### readPlacements

[Section titled “readPlacements”](#readplacements)

> **readPlacements**: () => `object`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:337](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L337)

Read serializable placement records from live state.

Use this for save data, editor panels, renderer diffing, and external ECS mirrors that do not need raw Koota relation stores.

#### Returns

[Section titled “Returns”](#returns-87)

***

### readPlacementsForTile

[Section titled “readPlacementsForTile”](#readplacementsfortile)

> **readPlacementsForTile**: (`coordinates`) => `object`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:344](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L344)

Read serializable placement records that occupy one tile.

This includes placements whose multi-tile footprint covers the tile, not only placements whose canonical origin is the tile.

#### Parameters

[Section titled “Parameters”](#parameters-80)

##### coordinates

[Section titled “coordinates”](#coordinates-4)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns-88)

***

### readQuests

[Section titled “readQuests”](#readquests)

> **readQuests**: () => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:564](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L564)

Read all quest snapshots from live state for HUDs, saves, and tests.

#### Returns

[Section titled “Returns”](#returns-89)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

***

### registerActor

[Section titled “registerActor”](#registeractor)

> **registerActor**: (`placement`, `options`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:528](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L528)

Attach actor state to an existing placement.

Register existing placements when a neutral prop, marker, structure, or externally declared piece becomes selectable, interactive, hostile, or quest-addressable after startup.

#### Parameters

[Section titled “Parameters”](#parameters-81)

##### placement

[Section titled “placement”](#placement-14)

`string` | `Entity`

##### options

[Section titled “options”](#options-67)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/)

#### Returns

[Section titled “Returns”](#returns-90)

`Entity`

***

### removePlacement

[Section titled “removePlacement”](#removeplacement-1)

> **removePlacement**: (`placement`) => `boolean`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:404](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L404)

Remove one placement entity and its placement relations from the live world.

Returns `false` when the entity or placement id cannot be found.

#### Parameters

[Section titled “Parameters”](#parameters-82)

##### placement

[Section titled “placement”](#placement-15)

`string` | `Entity`

#### Returns

[Section titled “Returns”](#returns-91)

`boolean`

***

### selectActors

[Section titled “selectActors”](#selectactors)

> **selectActors**: (`options?`) => [`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:416](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L416)

Select actors from live state using actor-aware filters.

#### Parameters

[Section titled “Parameters”](#parameters-83)

##### options?

[Section titled “options?”](#options-68)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/)

#### Returns

[Section titled “Returns”](#returns-92)

[`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

***

### selectPieces

[Section titled “selectPieces”](#selectpieces)

> **selectPieces**: (`registry`, `selection?`) => [`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:482](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L482)

Select declarations from a custom piece registry.

#### Parameters

[Section titled “Parameters”](#parameters-84)

##### registry

[Section titled “registry”](#registry-5)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### selection?

[Section titled “selection?”](#selection)

[`GameboardPieceRegistrySelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryselection/)

#### Returns

[Section titled “Returns”](#returns-93)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)\[]

***

### selectSpawnLocations

[Section titled “selectSpawnLocations”](#selectspawnlocations)

> **selectSpawnLocations**: (`options`) => [`SpawnLocation`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocation/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:431](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L431)

Select deterministic spawn locations from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-85)

##### options

[Section titled “options”](#options-69)

`GameboardSpawnLocationOptions`

#### Returns

[Section titled “Returns”](#returns-94)

[`SpawnLocation`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocation/)\[]

***

### snapshot

[Section titled “snapshot”](#snapshot)

> **snapshot**: (`options?`) => [`GameboardRuntimeSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimesnapshot/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:330](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L330)

Read a serializable runtime snapshot.

#### Parameters

[Section titled “Parameters”](#parameters-86)

##### options?

[Section titled “options?”](#options-70)

[`GameboardRuntimeSnapshotOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimesnapshotoptions/)

#### Returns

[Section titled “Returns”](#returns-95)

[`GameboardRuntimeSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimesnapshot/)

***

### spawnActor

[Section titled “spawnActor”](#spawnactor)

> **spawnActor**: (`options`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:520](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L520)

Spawn an actor-backed placement.

#### Parameters

[Section titled “Parameters”](#parameters-87)

##### options

[Section titled “options”](#options-71)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/)

#### Returns

[Section titled “Returns”](#returns-96)

`Entity`

***

### spawnLayoutFill

[Section titled “spawnLayoutFill”](#spawnlayoutfill)

> **spawnLayoutFill**: (`options`) => `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:455](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L455)

Spawn a generated layout fill into the live world.

#### Parameters

[Section titled “Parameters”](#parameters-88)

##### options

[Section titled “options”](#options-72)

[`GameboardLayoutFillOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfilloptions/)

#### Returns

[Section titled “Returns”](#returns-97)

`Entity`\[]

***

### spawnLayoutPlacements

[Section titled “spawnLayoutPlacements”](#spawnlayoutplacements)

> **spawnLayoutPlacements**: (`options`) => `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:453](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L453)

Spawn explicit layout placements into the live world.

#### Parameters

[Section titled “Parameters”](#parameters-89)

##### options

[Section titled “options”](#options-73)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-98)

`Entity`\[]

***

### spawnPiece

[Section titled “spawnPiece”](#spawnpiece)

> **spawnPiece**: (`piece`, `options?`) => `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:472](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L472)

Spawn one declared piece into the live world.

#### Parameters

[Section titled “Parameters”](#parameters-90)

##### piece

[Section titled “piece”](#piece-3)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

##### options?

[Section titled “options?”](#options-74)

[`GameboardPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-99)

`Entity`\[]

***

### spawnPieceFills

[Section titled “spawnPieceFills”](#spawnpiecefills)

> **spawnPieceFills**: (`registry`, `fills`, `options?`) => `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:509](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L509)

Spawn generated piece fills into the live world.

#### Parameters

[Section titled “Parameters”](#parameters-91)

##### registry

[Section titled “registry”](#registry-6)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### fills

[Section titled “fills”](#fills-2)

readonly [`SeededGameboardPieceFillOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefilloptions/)\[]

##### options?

[Section titled “options?”](#options-75)

[`InspectSeededGameboardPieceFillsOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectseededgameboardpiecefillsoptions/)

#### Returns

[Section titled “Returns”](#returns-100)

`Entity`\[]

***

### spawnPlacement

[Section titled “spawnPlacement”](#spawnplacement-1)

> **spawnPlacement**: (`options`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:376](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L376)

Spawn one renderable placement into the live world.

Pass `occupancyGuard: true` when the spawn should fail instead of overlapping an existing blocker or missing footprint tile.

#### Parameters

[Section titled “Parameters”](#parameters-92)

##### options

[Section titled “options”](#options-76)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-101)

`Entity`

***

### spawnQuest

[Section titled “spawnQuest”](#spawnquest)

> **spawnQuest**: (`definition`, `options?`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:557](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L557)

Spawn a quest definition into the live world.

Quest objectives can reference actor ids, placement ids, and tile keys, so scenario and runtime-created quests use the same progression surface.

#### Parameters

[Section titled “Parameters”](#parameters-93)

##### definition

[Section titled “definition”](#definition-1)

[`GameboardQuestDefinition`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestdefinition/)

##### options?

[Section titled “options?”](#options-77)

[`SpawnGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardquestoptions/)

#### Returns

[Section titled “Returns”](#returns-102)

`Entity`

***

### summarizePlan

[Section titled “summarizePlan”](#summarizeplan)

> **summarizePlan**: (`options?`) => [`GameboardPlanSummary`](/declarative-hex-worlds/reference/index/interfaces/gameboardplansummary/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:326](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L326)

Summarize the live projected plan for editor, diagnostics, and bridge code.

#### Parameters

[Section titled “Parameters”](#parameters-94)

##### options?

[Section titled “options?”](#options-78)

[`SummarizeGameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/summarizegameboardplanoptions/)

#### Returns

[Section titled “Returns”](#returns-103)

[`GameboardPlanSummary`](/declarative-hex-worlds/reference/index/interfaces/gameboardplansummary/)

***

### systems

[Section titled “systems”](#systems)

> `readonly` **systems**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:320](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L320)

System dispatch/tick actions.

#### dispatchActorTargetCommand

[Section titled “dispatchActorTargetCommand”](#dispatchactortargetcommand-1)

> **dispatchActorTargetCommand**: (`options`, `commandOptions`) => [`DispatchGameboardActorTargetCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardactortargetcommandresult/)

Select an actor target, then execute its planned command.

##### Parameters

[Section titled “Parameters”](#parameters-95)

###### options

[Section titled “options”](#options-79)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

###### commandOptions?

[Section titled “commandOptions?”](#commandoptions-1)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-104)

[`DispatchGameboardActorTargetCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardactortargetcommandresult/)

#### dispatchCommand

[Section titled “dispatchCommand”](#dispatchcommand-1)

> **dispatchCommand**: (`commandOrTarget`, `options`) => [`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

Execute one command and emit dispatch event records.

##### Parameters

[Section titled “Parameters”](#parameters-96)

###### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-6)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

###### options?

[Section titled “options?”](#options-80)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-105)

[`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

#### interact

[Section titled “interact”](#interact-1)

> **interact**: (`commandOrTarget`, `options`) => [`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/)

Dispatch a command and optionally tick systems.

##### Parameters

[Section titled “Parameters”](#parameters-97)

###### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-7)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

###### options?

[Section titled “options?”](#options-81)

[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-106)

[`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/)

#### interactActorTarget

[Section titled “interactActorTarget”](#interactactortarget-1)

> **interactActorTarget**: (`options`, `interactionOptions`) => [`RunGameboardActorTargetInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardactortargetinteractionresult/)

Target an actor, dispatch the command, and optionally tick systems.

##### Parameters

[Section titled “Parameters”](#parameters-98)

###### options

[Section titled “options”](#options-82)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

###### interactionOptions?

[Section titled “interactionOptions?”](#interactionoptions-1)

[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-107)

[`RunGameboardActorTargetInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardactortargetinteractionresult/)

#### run

[Section titled “run”](#run-1)

> **run**: (`options`) => [`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

Run enabled patrol, movement, and quest systems for one tick.

##### Parameters

[Section titled “Parameters”](#parameters-99)

###### options?

[Section titled “options?”](#options-83)

[`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-108)

[`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

***

### tick

[Section titled “tick”](#tick)

> **tick**: (`options?`) => [`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:612](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L612)

Run enabled systems for one game-loop tick.

#### Parameters

[Section titled “Parameters”](#parameters-100)

##### options?

[Section titled “options?”](#options-84)

[`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

#### Returns

[Section titled “Returns”](#returns-109)

[`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

***

### updateActor

[Section titled “updateActor”](#updateactor)

> **updateActor**: (`actor`, `options`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:533](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L533)

Update actor state while preserving omitted fields and placement binding.

#### Parameters

[Section titled “Parameters”](#parameters-101)

##### actor

[Section titled “actor”](#actor-6)

`string` | `Entity`

##### options

[Section titled “options”](#options-85)

[`UpdateGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardactoroptions/)

#### Returns

[Section titled “Returns”](#returns-110)

`Entity`

***

### updatePlacement

[Section titled “updatePlacement”](#updateplacement-1)

> **updatePlacement**: (`placement`, `options`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:384](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L384)

Update one placement in the live world while preserving omitted fields.

The helper refreshes placement classification and footprint relations when fields such as coordinates, kind, layer, footprint, tags, or blocking behavior change.

#### Parameters

[Section titled “Parameters”](#parameters-102)

##### placement

[Section titled “placement”](#placement-16)

`string` | `Entity`

##### options

[Section titled “options”](#options-86)

[`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-111)

`Entity`

***

### validationPlan

[Section titled “validationPlan”](#validationplan)

> **validationPlan**: () => [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:328](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L328)

Project the live world to a plan shape suitable for validation.

#### Returns

[Section titled “Returns”](#returns-112)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

***

### world

[Section titled “world”](#world)

> `readonly` **world**: `World`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:306](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L306)

Bound Koota world.

# GameboardRuntimeInteropOptions

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:498](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L498)

Options for runtime interop snapshots.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/)

## Properties

[Section titled “Properties”](#properties)

### includeActors?

[Section titled “includeActors?”](#includeactors)

> `optional` **includeActors?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:500](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L500)

Include actor entities and relations.

***

### includePlacements?

[Section titled “includePlacements?”](#includeplacements)

> `optional` **includePlacements?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:450](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L450)

Include placement entities and relations. Defaults to true.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/).[`includePlacements`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/#includeplacements)

***

### includeQuests?

[Section titled “includeQuests?”](#includequests)

> `optional` **includeQuests?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:502](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L502)

Include quest entities and relations.

***

### spawnLocations?

[Section titled “spawnLocations?”](#spawnlocations)

> `optional` **spawnLocations?**: `Omit`<[`SpawnLocationOptions`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocationoptions/), `"shape"`>

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:452](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L452)

Optional spawn-location generation options.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/).[`spawnLocations`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/#spawnlocations)

# GameboardRuntimeInteropState

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:484](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L484)

Runtime state accepted by runtime interop snapshots.

## Properties

[Section titled “Properties”](#properties)

### actors?

[Section titled “actors?”](#actors)

> `optional` **actors?**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:488](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L488)

Runtime actor snapshots.

***

### plan

[Section titled “plan”](#plan)

> **plan**: [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:486](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L486)

Current board plan.

***

### quests?

[Section titled “quests?”](#quests)

> `optional` **quests?**: readonly [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:490](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L490)

Runtime quest snapshots.

***

### scenario?

[Section titled “scenario?”](#scenario)

> `optional` **scenario?**: [`GameboardInteropScenarioRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropscenariorecord/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:492](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L492)

Optional scenario metadata.

# GameboardRuntimeSnapshot

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:276](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L276)

Full serializable snapshot of a live runtime facade.

## Properties

[Section titled “Properties”](#properties)

### actors

[Section titled “actors”](#actors)

> **actors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:288](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L288)

Current actor snapshots.

***

### interop?

[Section titled “interop?”](#interop)

> `optional` **interop?**: [`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:292](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L292)

Optional ECS interop snapshot.

***

### placementOccupancy

[Section titled “placementOccupancy”](#placementoccupancy)

> **placementOccupancy**: readonly [`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:286](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L286)

Current placement footprint occupancy records.

***

### placements

[Section titled “placements”](#placements)

> **placements**: readonly `object`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:284](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L284)

Current placement records.

***

### plan

[Section titled “plan”](#plan)

> **plan**: [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:280](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L280)

Renderable/current projected gameboard plan.

***

### quests

[Section titled “quests”](#quests)

> **quests**: readonly [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:290](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L290)

Current quest snapshots.

***

### state

[Section titled “state”](#state)

> **state**: [`GameboardSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:278](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L278)

Low-level board snapshot from Koota traits and relations.

***

### validationPlan?

[Section titled “validationPlan?”](#validationplan)

> `optional` **validationPlan?**: [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:282](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L282)

Validation-oriented plan when requested.

# GameboardRuntimeSnapshotOptions

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:266](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L266)

Snapshot options for the runtime facade.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/)

## Properties

[Section titled “Properties”](#properties)

### includeInterop?

[Section titled “includeInterop?”](#includeinterop)

> `optional` **includeInterop?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:268](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L268)

Include a runtime interop snapshot. Defaults to true.

***

### includePlacements?

[Section titled “includePlacements?”](#includeplacements)

> `optional` **includePlacements?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:450](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L450)

Include placement entities and relations. Defaults to true.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/).[`includePlacements`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/#includeplacements)

***

### includeValidationPlan?

[Section titled “includeValidationPlan?”](#includevalidationplan)

> `optional` **includeValidationPlan?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:270](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L270)

Include the validation-oriented plan projection.

***

### spawnLocations?

[Section titled “spawnLocations?”](#spawnlocations)

> `optional` **spawnLocations?**: `Omit`<[`SpawnLocationOptions`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocationoptions/), `"shape"`>

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:452](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L452)

Optional spawn-location generation options.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/).[`spawnLocations`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/#spawnlocations)

# GameboardScenario

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:96](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L96)

Serializable integration/e2e scenario using recipes, actors, routes, and quests.

## Properties

[Section titled “Properties”](#properties)

### actors?

[Section titled “actors?”](#actors)

> `optional` **actors?**: readonly [`GameboardScenarioActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenarioactor/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:110](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L110)

Actors to spawn into the scenario runtime.

***

### board

[Section titled “board”](#board)

> **board**: [`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:104](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L104)

Board recipe used to compile the scenario map.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:100](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L100)

Stable scenario id.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:114](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L114)

Additional serializable scenario metadata.

***

### patrolRoutes?

[Section titled “patrolRoutes?”](#patrolroutes)

> `optional` **patrolRoutes?**: readonly [`GameboardScenarioPatrolRoute`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariopatrolroute/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:108](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L108)

Deterministic patrol route rules for scenario actors.

***

### quests?

[Section titled “quests?”](#quests)

> `optional` **quests?**: readonly [`GameboardQuestDefinition`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestdefinition/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:112](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L112)

Quests to spawn into the scenario runtime.

***

### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> **schemaVersion**: `"1.0.0"`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:98](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L98)

Version tag for migration-safe scenario persistence.

***

### spawnGroups?

[Section titled “spawnGroups?”](#spawngroups)

> `optional` **spawnGroups?**: `GameboardSpawnGroupOptions`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:106](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L106)

Deterministic spawn group rules for scenario actors.

***

### title?

[Section titled “title?”](#title)

> `optional` **title?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:102](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L102)

Optional display title.

# GameboardScenarioActor

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:56](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L56)

Authored actor entry in a scenario, with optional spawn group resolution.

## Extends

[Section titled “Extends”](#extends)

* `Omit`<[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/), `"at"`>

## Properties

[Section titled “Properties”](#properties)

### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:54](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L54)

Stable gameplay actor id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`actorId`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#actorid)

***

### actorKind?

[Section titled “actorKind?”](#actorkind)

> `optional` **actorKind?**: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:56](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L56)

Gameplay actor kind. Defaults from placement kind.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`actorKind`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#actorkind)

***

### actorMetadata?

[Section titled “actorMetadata?”](#actormetadata)

> `optional` **actorMetadata?**: `Readonly`<`Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:70](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L70)

Serializable actor metadata independent from placement metadata.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`actorMetadata`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#actormetadata)

***

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:302](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L302)

Manifest or external registry asset id to render.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`assetId`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#assetid)

***

### at?

[Section titled “at?”](#at)

> `optional` **at?**: `string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L58)

Explicit spawn coordinate or tile key; omitted when using a spawn group.

***

### blocksMovement?

[Section titled “blocksMovement?”](#blocksmovement)

> `optional` **blocksMovement?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:64](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L64)

Whether this actor blocks actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`blocksMovement`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#blocksmovement)

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:310](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L310)

Extra vertical offset above the tile elevation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`elevationOffset`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#elevationoffset)

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `string` | `null`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L58)

Optional faction identifier.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`faction`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#faction)

***

### hostile?

[Section titled “hostile?”](#hostile)

> `optional` **hostile?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:62](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L62)

Whether this actor is generally hostile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`hostile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#hostile)

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:298](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L298)

Explicit placement id. Defaults to a deterministic runtime id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`id`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#id)

***

### interactive?

[Section titled “interactive?”](#interactive)

> `optional` **interactive?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:66](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L66)

Whether this actor should be considered an interaction target.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`interactive`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#interactive)

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:304](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L304)

Gameplay category for rules, selectors, and rendering.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`kind`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#kind)

***

### layer?

[Section titled “layer?”](#layer)

> `optional` **layer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:306](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L306)

Render and occupancy layer. Defaults from `kind`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`layer`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#layer)

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:324](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L324)

Serializable placement metadata for rules, ECS interop, and render hints.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`metadata`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#metadata)

***

### movementAgent?

[Section titled “movementAgent?”](#movementagent)

> `optional` **movementAgent?**: [`SetGameboardMovementAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardmovementagentoptions/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:64](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L64)

Optional movement agent to attach after spawning.

***

### occupancyGuard?

[Section titled “occupancyGuard?”](#occupancyguard)

> `optional` **occupancyGuard?**: [`GameboardPlacementOccupancyGuard`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementoccupancyguard/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:326](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L326)

Optional occupancy validation before spawning.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`occupancyGuard`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#occupancyguard)

***

### order?

[Section titled “order?”](#order)

> `optional` **order?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:318](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L318)

Stable sort order used by renderers and snapshots.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-14)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`order`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#order)

***

### patrolAgent?

[Section titled “patrolAgent?”](#patrolagent)

> `optional` **patrolAgent?**: [`GameboardScenarioActorPatrolAgent`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenarioactorpatrolagent/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:66](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L66)

Optional patrol agent to attach after spawning.

***

### positionOffset?

[Section titled “positionOffset?”](#positionoffset)

> `optional` **positionOffset?**: [`GameboardPlacementPositionOffset`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementpositionoffset/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:312](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L312)

Local world-space offset after tile/elevation anchoring.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-15)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`positionOffset`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#positionoffset)

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:322](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L322)

Whether the placement depends on local-only EXTRA assets.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-16)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`requiresExtra`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#requiresextra)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:314](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L314)

Clockwise 60-degree rotation steps.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-17)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:316](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L316)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-18)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#scale)

***

### spawnGroupId?

[Section titled “spawnGroupId?”](#spawngroupid)

> `optional` **spawnGroupId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:60](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L60)

Spawn group id to claim a deterministic spawn location from.

***

### spawnLocationIndex?

[Section titled “spawnLocationIndex?”](#spawnlocationindex)

> `optional` **spawnLocationIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:62](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L62)

Explicit spawn location index inside the referenced spawn group.

***

### stackIndex?

[Section titled “stackIndex?”](#stackindex)

> `optional` **stackIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:320](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L320)

Optional stack index for layered terrain and vertical props.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-19)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`stackIndex`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#stackindex)

***

### tags?

[Section titled “tags?”](#tags)

> `optional` **tags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:68](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L68)

Free-form actor tags used by selectors and quests.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-20)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`tags`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#tags)

***

### team?

[Section titled “team?”](#team)

> `optional` **team?**: `string` | `null`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:60](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L60)

Optional team identifier. Defaults to faction when omitted.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-21)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`team`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#team)

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:308](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L308)

Texture set override. Defaults to the origin tile texture set.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-22)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`textureSet`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#textureset)

# GameboardScenarioActorPatrolAgent

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:89](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L89)

Patrol agent definition that references a named scenario route.

## Extends

[Section titled “Extends”](#extends)

* `Omit`<[`SetGameboardPatrolAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardpatrolagentoptions/), `"route"`>

## Properties

[Section titled “Properties”](#properties)

### active?

[Section titled “active?”](#active)

> `optional` **active?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:63](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L63)

Whether the patrol starts active.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`SetGameboardPatrolAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardpatrolagentoptions/).[`active`](/declarative-hex-worlds/reference/index/interfaces/setgameboardpatrolagentoptions/#active)

***

### alignToCurrentTile?

[Section titled “alignToCurrentTile?”](#aligntocurrenttile)

> `optional` **alignToCurrentTile?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:61](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L61)

Align starting waypoint to the placement’s current tile when possible.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`SetGameboardPatrolAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardpatrolagentoptions/).[`alignToCurrentTile`](/declarative-hex-worlds/reference/index/interfaces/setgameboardpatrolagentoptions/#aligntocurrenttile)

***

### currentWaypointIndex?

[Section titled “currentWaypointIndex?”](#currentwaypointindex)

> `optional` **currentWaypointIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:59](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L59)

Starting waypoint index.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`SetGameboardPatrolAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardpatrolagentoptions/).[`currentWaypointIndex`](/declarative-hex-worlds/reference/index/interfaces/setgameboardpatrolagentoptions/#currentwaypointindex)

***

### movement?

[Section titled “movement?”](#movement)

> `optional` **movement?**: [`GameboardMovementPathRequestOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementpathrequestoptions/)

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L67)

Movement options used when requesting segment movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`SetGameboardPatrolAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardpatrolagentoptions/).[`movement`](/declarative-hex-worlds/reference/index/interfaces/setgameboardpatrolagentoptions/#movement)

***

### pauseTicks?

[Section titled “pauseTicks?”](#pauseticks)

> `optional` **pauseTicks?**: `number`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L65)

Ticks to wait after reaching each waypoint.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`SetGameboardPatrolAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardpatrolagentoptions/).[`pauseTicks`](/declarative-hex-worlds/reference/index/interfaces/setgameboardpatrolagentoptions/#pauseticks)

***

### routeId

[Section titled “routeId”](#routeid)

> **routeId**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:92](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L92)

Scenario patrol route id to attach to the actor.

# GameboardScenarioActorSummary

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:197](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L197)

Serializable row for one authored or spawn-group-resolved scenario actor.

## Properties

[Section titled “Properties”](#properties)

### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:199](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L199)

Stable actor id.

***

### actorKind

[Section titled “actorKind”](#actorkind)

> **actorKind**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:201](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L201)

Gameplay actor kind.

***

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:203](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L203)

Manifest or external registry asset id.

***

### blocksMovement

[Section titled “blocksMovement”](#blocksmovement)

> **blocksMovement**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:221](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L221)

Whether this actor blocks movement.

***

### hostile

[Section titled “hostile”](#hostile)

> **hostile**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:217](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L217)

Whether this actor is generally hostile.

***

### interactive

[Section titled “interactive”](#interactive)

> **interactive**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:219](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L219)

Whether this actor is an interaction target.

***

### movementProfileId?

[Section titled “movementProfileId?”](#movementprofileid)

> `optional` **movementProfileId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:211](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L211)

Movement profile id, when a movement agent is authored.

***

### patrolRouteId?

[Section titled “patrolRouteId?”](#patrolrouteid)

> `optional` **patrolRouteId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:213](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L213)

Referenced patrol route, when a patrol agent is authored.

***

### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:223](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L223)

Whether this actor depends on local-only assets.

***

### spawnGroupId?

[Section titled “spawnGroupId?”](#spawngroupid)

> `optional` **spawnGroupId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:207](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L207)

Referenced spawn group, when any.

***

### spawnLocationIndex?

[Section titled “spawnLocationIndex?”](#spawnlocationindex)

> `optional` **spawnLocationIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:209](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L209)

Claimed spawn location index, when any.

***

### tags

[Section titled “tags”](#tags)

> **tags**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:225](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L225)

Selector tags authored on the actor.

***

### team?

[Section titled “team?”](#team)

> `optional` **team?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:215](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L215)

Team or faction id used for interaction logic.

***

### tileKey?

[Section titled “tileKey?”](#tilekey)

> `optional` **tileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:205](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L205)

Resolved or explicit spawn tile key, when known.

# GameboardScenarioAssetSummary

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:183](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L183)

Asset-level count and gameplay treatment for scenario actors.

## Properties

[Section titled “Properties”](#properties)

### actorKinds

[Section titled “actorKinds”](#actorkinds)

> **actorKinds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:191](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L191)

Actor kinds using this asset.

***

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:185](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L185)

Manifest or external registry asset id.

***

### count

[Section titled “count”](#count)

> **count**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:187](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L187)

Number of actors that use the asset.

***

### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:189](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L189)

Whether any actor using this asset requires local-only assets.

***

### teams

[Section titled “teams”](#teams)

> **teams**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:193](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L193)

Teams or factions using this asset.

# GameboardScenarioGameRuntime

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:619](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L619)

Runtime facade created from a scenario, preserving scenario-specific indexes and source URL helpers.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/)

## Properties

[Section titled “Properties”](#properties)

### actions

[Section titled “actions”](#actions)

> `readonly` **actions**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:308](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L308)

Raw board placement actions.

#### canOccupyPlacement

[Section titled “canOccupyPlacement”](#canoccupyplacement)

> **canOccupyPlacement**: (`options`) => `boolean`

Return only the boolean occupancy result for a proposed placement.

##### Parameters

[Section titled “Parameters”](#parameters)

###### options

[Section titled “options”](#options)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/)

##### Returns

[Section titled “Returns”](#returns)

`boolean`

#### clear

[Section titled “clear”](#clear)

> **clear**: () => `void`

Remove all board tile, placement, and board-state traits from the world.

##### Returns

[Section titled “Returns”](#returns-1)

`void`

#### inspectPlacementOccupancy

[Section titled “inspectPlacementOccupancy”](#inspectplacementoccupancy)

> **inspectPlacementOccupancy**: (`options`) => [`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/)

Inspect whether a proposed placement footprint can occupy its target tiles.

##### Parameters

[Section titled “Parameters”](#parameters-1)

###### options

[Section titled “options”](#options-1)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/)

##### Returns

[Section titled “Returns”](#returns-2)

[`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/)

#### loadPlan

[Section titled “loadPlan”](#loadplan)

> **loadPlan**: (`plan`) => [`GameboardEntityIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardentityindex/)

Replace the current world contents with a complete generated board plan.

##### Parameters

[Section titled “Parameters”](#parameters-2)

###### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

##### Returns

[Section titled “Returns”](#returns-3)

[`GameboardEntityIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardentityindex/)

#### movePlacement

[Section titled “movePlacement”](#moveplacement)

> **movePlacement**: (`placement`, `to`, `options`) => `Entity`

Move an existing placement to another tile while preserving unspecified state.

##### Parameters

[Section titled “Parameters”](#parameters-3)

###### placement

[Section titled “placement”](#placement)

`string` | `Entity`

###### to

[Section titled “to”](#to)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

###### options?

[Section titled “options?”](#options-2)

[`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-4)

`Entity`

#### removePlacement

[Section titled “removePlacement”](#removeplacement)

> **removePlacement**: (`placement`) => `boolean`

Remove an existing placement by entity or placement id.

##### Parameters

[Section titled “Parameters”](#parameters-4)

###### placement

[Section titled “placement”](#placement-1)

`string` | `Entity`

##### Returns

[Section titled “Returns”](#returns-5)

`boolean`

#### spawnPlacement

[Section titled “spawnPlacement”](#spawnplacement)

> **spawnPlacement**: (`options`) => `Entity`

Spawn a runtime placement into the board.

##### Parameters

[Section titled “Parameters”](#parameters-5)

###### options

[Section titled “options”](#options-3)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)

##### Returns

[Section titled “Returns”](#returns-6)

`Entity`

#### updatePlacement

[Section titled “updatePlacement”](#updateplacement)

> **updatePlacement**: (`placement`, `options`) => `Entity`

Update an existing runtime placement by entity or placement id.

##### Parameters

[Section titled “Parameters”](#parameters-6)

###### placement

[Section titled “placement”](#placement-2)

`string` | `Entity`

###### options

[Section titled “options”](#options-4)

[`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/)

##### Returns

[Section titled “Returns”](#returns-7)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`actions`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#actions)

***

### actorEntities

[Section titled “actorEntities”](#actorentities)

> `readonly` **actorEntities**: `Readonly`<`Record`<`string`, `Entity`>>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:623](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L623)

Scenario actor entity index by actor id.

***

### actors

[Section titled “actors”](#actors)

> `readonly` **actors**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:310](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L310)

Actor actions.

#### collision

[Section titled “collision”](#collision)

> **collision**: (`actor`, `target`, `profile`) => [`GameboardActorCollisionReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionreport/)

Inspect whether an actor can enter a target tile.

##### Parameters

[Section titled “Parameters”](#parameters-7)

###### actor

[Section titled “actor”](#actor)

`string` | `Entity` | `undefined`

###### target

[Section titled “target”](#target)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

###### profile?

[Section titled “profile?”](#profile)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/) = `{}`

##### Returns

[Section titled “Returns”](#returns-8)

[`GameboardActorCollisionReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionreport/)

#### command

[Section titled “command”](#command)

> **command**: (`target`, `options`) => [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

Plan a high-level interaction command from a target input.

##### Parameters

[Section titled “Parameters”](#parameters-8)

###### target

[Section titled “target”](#target-1)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

###### options?

[Section titled “options?”](#options-5)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-9)

[`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

#### interaction

[Section titled “interaction”](#interaction)

> **interaction**: (`target`, `options`) => [`GameboardInteractionTargetReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetreport/)

Resolve and inspect an interaction target.

##### Parameters

[Section titled “Parameters”](#parameters-9)

###### target

[Section titled “target”](#target-2)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

###### options?

[Section titled “options?”](#options-6)

[`GameboardInteractionTargetOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-10)

[`GameboardInteractionTargetReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetreport/)

#### move

[Section titled “move”](#move)

> **move**: (`actor`, `to`, `options`) => `Entity`

Move an actor to another tile.

##### Parameters

[Section titled “Parameters”](#parameters-10)

###### actor

[Section titled “actor”](#actor-1)

`string` | `Entity`

###### to

[Section titled “to”](#to-1)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

###### options?

[Section titled “options?”](#options-7)

[`MoveGameboardActorOptions`](/declarative-hex-worlds/reference/index/type-aliases/movegameboardactoroptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-11)

`Entity`

#### navigationProfile

[Section titled “navigationProfile”](#navigationprofile)

> **navigationProfile**: (`actor`, `options`) => [`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

Create an actor-aware navigation profile.

##### Parameters

[Section titled “Parameters”](#parameters-11)

###### actor

[Section titled “actor”](#actor-2)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-8)

[`GameboardActorNavigationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactornavigationoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-12)

[`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

#### neighborhood

[Section titled “neighborhood”](#neighborhood)

> **neighborhood**: (`center`, `options`) => [`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

Inspect a radius of tiles around a center.

##### Parameters

[Section titled “Parameters”](#parameters-12)

###### center

[Section titled “center”](#center)

[`GameboardNeighborhoodCenter`](/declarative-hex-worlds/reference/index/type-aliases/gameboardneighborhoodcenter/)

###### options?

[Section titled “options?”](#options-9)

[`GameboardNeighborhoodInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspectionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-13)

[`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

#### read

[Section titled “read”](#read)

> **read**: () => [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Read all registered actors.

##### Returns

[Section titled “Returns”](#returns-14)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

#### register

[Section titled “register”](#register)

> **register**: (`placement`, `options`) => `Entity`

Register an existing placement as an actor.

##### Parameters

[Section titled “Parameters”](#parameters-13)

###### placement

[Section titled “placement”](#placement-3)

`string` | `Entity`

###### options

[Section titled “options”](#options-10)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/)

##### Returns

[Section titled “Returns”](#returns-15)

`Entity`

#### select

[Section titled “select”](#select)

> **select**: (`options`) => [`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

Select actors with optional faction, team, tag, radius, and hostility filters.

##### Parameters

[Section titled “Parameters”](#parameters-14)

###### options?

[Section titled “options?”](#options-11)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-16)

[`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

#### spawn

[Section titled “spawn”](#spawn)

> **spawn**: (`options`) => `Entity`

Spawn a placement and register it as an actor.

##### Parameters

[Section titled “Parameters”](#parameters-15)

###### options

[Section titled “options”](#options-12)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/)

##### Returns

[Section titled “Returns”](#returns-17)

`Entity`

#### targets

[Section titled “targets”](#targets)

> **targets**: (`options`) => [`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/)

Select and path to candidate actor targets.

##### Parameters

[Section titled “Parameters”](#parameters-16)

###### options

[Section titled “options”](#options-13)

[`GameboardActorTargetingOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/)

##### Returns

[Section titled “Returns”](#returns-18)

[`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/)

#### tile

[Section titled “tile”](#tile)

> **tile**: (`coordinates`, `options`) => [`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

Inspect one tile from an actor/gameplay perspective.

##### Parameters

[Section titled “Parameters”](#parameters-17)

###### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

###### options?

[Section titled “options?”](#options-14)

[`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-19)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

#### update

[Section titled “update”](#update)

> **update**: (`actor`, `options`) => `Entity`

Update actor trait state while preserving omitted fields.

##### Parameters

[Section titled “Parameters”](#parameters-18)

###### actor

[Section titled “actor”](#actor-3)

`string` | `Entity`

###### options

[Section titled “options”](#options-15)

[`UpdateGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardactoroptions/)

##### Returns

[Section titled “Returns”](#returns-20)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`actors`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#actors)

***

### advanceAllQuests

[Section titled “advanceAllQuests”](#advanceallquests)

> **advanceAllQuests**: (`options?`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:571](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L571)

Advance every quest against the current live actor, placement, and tile state.

#### Parameters

[Section titled “Parameters”](#parameters-19)

##### options?

[Section titled “options?”](#options-16)

[`AdvanceGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardquestoptions/)

#### Returns

[Section titled “Returns”](#returns-21)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`advanceAllQuests`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#advanceallquests)

***

### advanceQuest

[Section titled “advanceQuest”](#advancequest)

> **advanceQuest**: (`quest`, `options?`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:566](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L566)

Advance one quest against the current live actor, placement, and tile state.

#### Parameters

[Section titled “Parameters”](#parameters-20)

##### quest

[Section titled “quest”](#quest)

`string` | `Entity`

##### options?

[Section titled “options?”](#options-17)

[`AdvanceGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardquestoptions/)

#### Returns

[Section titled “Returns”](#returns-22)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`advanceQuest`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#advancequest)

***

### analyzeLayoutFill

[Section titled “analyzeLayoutFill”](#analyzelayoutfill)

> **analyzeLayoutFill**: (`options`) => [`GameboardLayoutFillAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillanalysis/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:447](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L447)

Analyze seeded layout fill rules against the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-21)

##### options

[Section titled “options”](#options-18)

[`GameboardLayoutFillOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfilloptions/)

#### Returns

[Section titled “Returns”](#returns-23)

[`GameboardLayoutFillAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillanalysis/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`analyzeLayoutFill`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#analyzelayoutfill)

***

### analyzePieceFills

[Section titled “analyzePieceFills”](#analyzepiecefills)

> **analyzePieceFills**: (`registry`, `fills`, `options?`) => [`GameboardLayoutFillAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillanalysis/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:497](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L497)

Analyze generated piece fills against the current projected plan.

#### Parameters

[Section titled “Parameters”](#parameters-22)

##### registry

[Section titled “registry”](#registry)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### fills

[Section titled “fills”](#fills)

readonly [`SeededGameboardPieceFillOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefilloptions/)\[]

##### options?

[Section titled “options?”](#options-19)

[`InspectSeededGameboardPieceFillsOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectseededgameboardpiecefillsoptions/)

#### Returns

[Section titled “Returns”](#returns-24)

[`GameboardLayoutFillAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillanalysis/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`analyzePieceFills`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#analyzepiecefills)

***

### analyzePieceRegistry

[Section titled “analyzePieceRegistry”](#analyzepieceregistry)

> **analyzePieceRegistry**: (`registry`, `options?`) => [`GameboardPieceRegistryAnalysis`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryanalysis/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:477](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L477)

Analyze a custom piece registry.

#### Parameters

[Section titled “Parameters”](#parameters-23)

##### registry

[Section titled “registry”](#registry-1)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### options?

[Section titled “options?”](#options-20)

[`AnalyzeGameboardPieceRegistryOptions`](/declarative-hex-worlds/reference/index/interfaces/analyzegameboardpieceregistryoptions/)

#### Returns

[Section titled “Returns”](#returns-25)

[`GameboardPieceRegistryAnalysis`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryanalysis/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`analyzePieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#analyzepieceregistry)

***

### canOccupyPlacement

[Section titled “canOccupyPlacement”](#canoccupyplacement-1)

> **canOccupyPlacement**: (`options`) => `boolean`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:369](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L369)

Return the boolean result from `inspectPlacementOccupancy`.

#### Parameters

[Section titled “Parameters”](#parameters-24)

##### options

[Section titled “options”](#options-21)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/)

#### Returns

[Section titled “Returns”](#returns-26)

`boolean`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`canOccupyPlacement`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#canoccupyplacement)

***

### commands

[Section titled “commands”](#commands)

> `readonly` **commands**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:318](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L318)

Command planning/execution actions.

#### execute

[Section titled “execute”](#execute)

> **execute**: (`commandOrTarget`, `options`) => [`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

Execute a command with optional host-game handlers.

##### Parameters

[Section titled “Parameters”](#parameters-25)

###### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

###### options?

[Section titled “options?”](#options-22)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-27)

[`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

#### plan

[Section titled “plan”](#plan-1)

> **plan**: (`target`, `options`) => [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

Plan a command from a renderer or gameplay target.

##### Parameters

[Section titled “Parameters”](#parameters-26)

###### target

[Section titled “target”](#target-3)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

###### options?

[Section titled “options?”](#options-23)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-28)

[`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

#### preview

[Section titled “preview”](#preview)

> **preview**: (`commandOrTarget`, `options`) => [`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

Preview a command without mutating state.

##### Parameters

[Section titled “Parameters”](#parameters-27)

###### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-1)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

###### options?

[Section titled “options?”](#options-24)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-29)

[`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

#### targetCommand

[Section titled “targetCommand”](#targetcommand)

> **targetCommand**: (`options`) => [`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

Select an actor target and plan a command against it.

##### Parameters

[Section titled “Parameters”](#parameters-28)

###### options

[Section titled “options”](#options-25)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

##### Returns

[Section titled “Returns”](#returns-30)

[`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`commands`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#commands)

***

### createInteropSnapshot

[Section titled “createInteropSnapshot”](#createinteropsnapshot)

> **createInteropSnapshot**: (`options?`) => [`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:420](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L420)

Create an ECS interop snapshot from the live runtime.

#### Parameters

[Section titled “Parameters”](#parameters-29)

##### options?

[Section titled “options?”](#options-26)

[`GameboardRuntimeInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimeinteropoptions/)

#### Returns

[Section titled “Returns”](#returns-31)

[`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createinteropsnapshot)

***

### createLayoutFillPlacements

[Section titled “createLayoutFillPlacements”](#createlayoutfillplacements)

> **createLayoutFillPlacements**: (`options`) => [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:449](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L449)

Create seeded layout fill placement options without mutating the live world.

#### Parameters

[Section titled “Parameters”](#parameters-30)

##### options

[Section titled “options”](#options-27)

[`GameboardLayoutFillOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfilloptions/)

#### Returns

[Section titled “Returns”](#returns-32)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createLayoutFillPlacements`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createlayoutfillplacements)

***

### createLayoutPlacements

[Section titled “createLayoutPlacements”](#createlayoutplacements)

> **createLayoutPlacements**: (`options`) => [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:443](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L443)

Create layout placement spawn options without mutating the live world.

#### Parameters

[Section titled “Parameters”](#parameters-31)

##### options

[Section titled “options”](#options-28)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-33)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createLayoutPlacements`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createlayoutplacements)

***

### createNavigation

[Section titled “createNavigation”](#createnavigation)

> **createNavigation**: (`profile?`) => [`GameboardNavigation`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigation/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:429](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L429)

Create a pathfinding/navigation facade from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-32)

##### profile?

[Section titled “profile?”](#profile-1)

[`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

#### Returns

[Section titled “Returns”](#returns-34)

[`GameboardNavigation`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigation/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createNavigation`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createnavigation)

***

### createOccupancyIndex

[Section titled “createOccupancyIndex”](#createoccupancyindex)

> **createOccupancyIndex**: (`profile?`) => [`GameboardOccupancyIndex`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardoccupancyindex/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:427](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L427)

Create a navigation occupancy index from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-33)

##### profile?

[Section titled “profile?”](#profile-2)

[`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

#### Returns

[Section titled “Returns”](#returns-35)

[`GameboardOccupancyIndex`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardoccupancyindex/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createOccupancyIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createoccupancyindex)

***

### createPieceFillRules

[Section titled “createPieceFillRules”](#createpiecefillrules)

> **createPieceFillRules**: (`registry`, `options?`) => [`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:487](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L487)

Create layout fill rules from selected registry pieces.

#### Parameters

[Section titled “Parameters”](#parameters-34)

##### registry

[Section titled “registry”](#registry-2)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### options?

[Section titled “options?”](#options-29)

[`GameboardPieceRegistryFillRulesOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryfillrulesoptions/)

#### Returns

[Section titled “Returns”](#returns-36)

[`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-14)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createPieceFillRules`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createpiecefillrules)

***

### createPiecePlacementOptions

[Section titled “createPiecePlacementOptions”](#createpieceplacementoptions)

> **createPiecePlacementOptions**: (`piece`, `options?`) => [`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:457](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L457)

Convert a piece declaration to layout placement options.

#### Parameters

[Section titled “Parameters”](#parameters-35)

##### piece

[Section titled “piece”](#piece)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

##### options?

[Section titled “options?”](#options-30)

[`GameboardPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-37)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-15)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createpieceplacementoptions)

***

### createPiecePlacements

[Section titled “createPiecePlacements”](#createpieceplacements)

> **createPiecePlacements**: (`piece`, `options?`) => [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:462](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L462)

Create placement options for a piece against the current projected plan.

#### Parameters

[Section titled “Parameters”](#parameters-36)

##### piece

[Section titled “piece”](#piece-1)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

##### options?

[Section titled “options?”](#options-31)

[`GameboardPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-38)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-16)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createPiecePlacements`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createpieceplacements)

***

### createPiecePoolFillRule

[Section titled “createPiecePoolFillRule”](#createpiecepoolfillrule)

> **createPiecePoolFillRule**: (`pieces`, `options?`) => [`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:492](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L492)

Create one pooled fill rule from a piece collection.

#### Parameters

[Section titled “Parameters”](#parameters-37)

##### pieces

[Section titled “pieces”](#pieces)

readonly [`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)\[]

##### options?

[Section titled “options?”](#options-32)

[`GameboardPieceCollectionLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiececollectionlayoutruleoptions/)

#### Returns

[Section titled “Returns”](#returns-39)

[`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-17)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createPiecePoolFillRule`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createpiecepoolfillrule)

***

### createPieceSourceUrlMap

[Section titled “createPieceSourceUrlMap”](#createpiecesourceurlmap)

> **createPieceSourceUrlMap**: (`registry`, `options?`) => `Readonly`<`Record`<`string`, `string`>>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:515](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L515)

Create an asset-id-to-URL map for local custom pieces.

#### Parameters

[Section titled “Parameters”](#parameters-38)

##### registry

[Section titled “registry”](#registry-3)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### options?

[Section titled “options?”](#options-33)

[`GameboardPieceSourceUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecesourceurloptions/)

#### Returns

[Section titled “Returns”](#returns-40)

`Readonly`<`Record`<`string`, `string`>>

#### Inherited from

[Section titled “Inherited from”](#inherited-from-18)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`createPieceSourceUrlMap`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#createpiecesourceurlmap)

***

### createScenarioInteropSnapshot

[Section titled “createScenarioInteropSnapshot”](#createscenariointeropsnapshot)

> **createScenarioInteropSnapshot**: (`options?`) => [`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:635](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L635)

Create an interop snapshot from the original scenario definition.

#### Parameters

[Section titled “Parameters”](#parameters-39)

##### options?

[Section titled “options?”](#options-34)

[`GameboardScenarioInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariointeropoptions/)

#### Returns

[Section titled “Returns”](#returns-41)

[`GameboardInteropSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropsnapshot/)

***

### createScenarioPieceSourceUrlMap

[Section titled “createScenarioPieceSourceUrlMap”](#createscenariopiecesourceurlmap)

> **createScenarioPieceSourceUrlMap**: (`options?`) => `Readonly`<`Record`<`string`, `string`>>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:646](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L646)

Create an asset-id-to-URL map for scenario-local custom pieces.

#### Parameters

[Section titled “Parameters”](#parameters-40)

##### options?

[Section titled “options?”](#options-35)

[`GameboardPieceSourceUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecesourceurloptions/)

#### Returns

[Section titled “Returns”](#returns-42)

`Readonly`<`Record`<`string`, `string`>>

***

### dispatchActorTargetCommand

[Section titled “dispatchActorTargetCommand”](#dispatchactortargetcommand)

> **dispatchActorTargetCommand**: (`options`, `commandOptions?`) => [`DispatchGameboardActorTargetCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardactortargetcommandresult/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:592](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L592)

Select an actor target and dispatch the planned command.

#### Parameters

[Section titled “Parameters”](#parameters-41)

##### options

[Section titled “options”](#options-36)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

##### commandOptions?

[Section titled “commandOptions?”](#commandoptions)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/)

#### Returns

[Section titled “Returns”](#returns-43)

[`DispatchGameboardActorTargetCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardactortargetcommandresult/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-19)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`dispatchActorTargetCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#dispatchactortargetcommand)

***

### dispatchCommand

[Section titled “dispatchCommand”](#dispatchcommand)

> **dispatchCommand**: (`commandOrTarget`, `options?`) => [`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:587](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L587)

Execute a command and return dispatch events.

#### Parameters

[Section titled “Parameters”](#parameters-42)

##### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-2)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

##### options?

[Section titled “options?”](#options-37)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/)

#### Returns

[Section titled “Returns”](#returns-44)

[`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-20)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`dispatchCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#dispatchcommand)

***

### executeCommand

[Section titled “executeCommand”](#executecommand)

> **executeCommand**: (`commandOrTarget`, `options?`) => [`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:597](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L597)

Execute a command without wrapping it in system events.

#### Parameters

[Section titled “Parameters”](#parameters-43)

##### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-3)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

##### options?

[Section titled “options?”](#options-38)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/)

#### Returns

[Section titled “Returns”](#returns-45)

[`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-21)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`executeCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#executecommand)

***

### findActor

[Section titled “findActor”](#findactor)

> **findActor**: (`actor`) => [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:535](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L535)

Find one actor by entity, placement id, or stable actor id.

#### Parameters

[Section titled “Parameters”](#parameters-44)

##### actor

[Section titled “actor”](#actor-4)

`string` | `Entity`

#### Returns

[Section titled “Returns”](#returns-46)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/) | `undefined`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-22)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`findActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#findactor)

***

### findQuest

[Section titled “findQuest”](#findquest)

> **findQuest**: (`quest`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:562](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L562)

Find one quest by entity or stable quest id.

#### Parameters

[Section titled “Parameters”](#parameters-45)

##### quest

[Section titled “quest”](#quest-1)

`string` | `Entity`

#### Returns

[Section titled “Returns”](#returns-47)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/) | `undefined`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-23)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`findQuest`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#findquest)

***

### inspectActorTargets

[Section titled “inspectActorTargets”](#inspectactortargets)

> **inspectActorTargets**: (`options`) => [`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:418](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L418)

Select and rank actor targets with path and command planning.

#### Parameters

[Section titled “Parameters”](#parameters-46)

##### options

[Section titled “options”](#options-39)

[`GameboardActorTargetingOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/)

#### Returns

[Section titled “Returns”](#returns-48)

[`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-24)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`inspectActorTargets`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#inspectactortargets)

***

### inspectLayoutSites

[Section titled “inspectLayoutSites”](#inspectlayoutsites)

> **inspectLayoutSites**: (`options?`) => [`GameboardLayoutSiteInspection`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutsiteinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:439](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L439)

Inspect layout candidates and rejections against the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-47)

##### options?

[Section titled “options?”](#options-40)

[`InspectGameboardLayoutSitesOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/inspectgameboardlayoutsitesoptions/)

#### Returns

[Section titled “Returns”](#returns-49)

[`GameboardLayoutSiteInspection`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutsiteinspection/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-25)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`inspectLayoutSites`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#inspectlayoutsites)

***

### inspectNeighborhood

[Section titled “inspectNeighborhood”](#inspectneighborhood)

> **inspectNeighborhood**: (`center`, `options?`) => [`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:411](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L411)

Inspect a radius around a tile, placement, actor, or coordinate.

#### Parameters

[Section titled “Parameters”](#parameters-48)

##### center

[Section titled “center”](#center-1)

[`GameboardNeighborhoodCenter`](/declarative-hex-worlds/reference/index/type-aliases/gameboardneighborhoodcenter/)

##### options?

[Section titled “options?”](#options-41)

[`GameboardNeighborhoodInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspectionoptions/)

#### Returns

[Section titled “Returns”](#returns-50)

[`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-26)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`inspectNeighborhood`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#inspectneighborhood)

***

### inspectPieceFills

[Section titled “inspectPieceFills”](#inspectpiecefills)

> **inspectPieceFills**: (`registry`, `fills`, `options?`) => [`SeededGameboardPieceFillInspection`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefillinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:503](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L503)

Inspect generated piece fills with candidate and rejection details.

#### Parameters

[Section titled “Parameters”](#parameters-49)

##### registry

[Section titled “registry”](#registry-4)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### fills

[Section titled “fills”](#fills-1)

readonly [`SeededGameboardPieceFillOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefilloptions/)\[]

##### options?

[Section titled “options?”](#options-42)

[`InspectSeededGameboardPieceFillsOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectseededgameboardpiecefillsoptions/)

#### Returns

[Section titled “Returns”](#returns-51)

[`SeededGameboardPieceFillInspection`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefillinspection/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-27)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`inspectPieceFills`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#inspectpiecefills)

***

### inspectPiecePlacement

[Section titled “inspectPiecePlacement”](#inspectpieceplacement)

> **inspectPiecePlacement**: (`piece`, `options?`) => [`GameboardPiecePlacementInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:467](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L467)

Inspect where a piece can be placed against the current projected plan.

#### Parameters

[Section titled “Parameters”](#parameters-50)

##### piece

[Section titled “piece”](#piece-2)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

##### options?

[Section titled “options?”](#options-43)

[`GameboardPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-52)

[`GameboardPiecePlacementInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementinspection/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-28)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`inspectPiecePlacement`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#inspectpieceplacement)

***

### inspectPlacementOccupancy

[Section titled “inspectPlacementOccupancy”](#inspectplacementoccupancy-1)

> **inspectPlacementOccupancy**: (`options`) => [`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:365](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L365)

Inspect whether a placement footprint can occupy the current live board.

This is the preflight path for construction cursors, drag previews, unit moves, and generated fills before mutating the world.

#### Parameters

[Section titled “Parameters”](#parameters-51)

##### options

[Section titled “options”](#options-44)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/)

#### Returns

[Section titled “Returns”](#returns-53)

[`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-29)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`inspectPlacementOccupancy`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#inspectplacementoccupancy)

***

### inspectTile

[Section titled “inspectTile”](#inspecttile)

> **inspectTile**: (`coordinates`, `options?`) => [`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:406](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L406)

Inspect one tile, placement, actor, or coordinate in live state.

#### Parameters

[Section titled “Parameters”](#parameters-52)

##### coordinates

[Section titled “coordinates”](#coordinates-1)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### options?

[Section titled “options?”](#options-45)

[`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/)

#### Returns

[Section titled “Returns”](#returns-54)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-30)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`inspectTile`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#inspecttile)

***

### interact

[Section titled “interact”](#interact)

> **interact**: (`commandOrTarget`, `options?`) => [`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:602](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L602)

Dispatch a command and optionally run systems.

#### Parameters

[Section titled “Parameters”](#parameters-53)

##### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-4)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

##### options?

[Section titled “options?”](#options-46)

[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/)

#### Returns

[Section titled “Returns”](#returns-55)

[`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-31)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`interact`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#interact)

***

### interactActorTarget

[Section titled “interactActorTarget”](#interactactortarget)

> **interactActorTarget**: (`options`, `interactionOptions?`) => [`RunGameboardActorTargetInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardactortargetinteractionresult/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:607](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L607)

Target an actor, dispatch the command, and optionally run systems.

#### Parameters

[Section titled “Parameters”](#parameters-54)

##### options

[Section titled “options”](#options-47)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

##### interactionOptions?

[Section titled “interactionOptions?”](#interactionoptions)

[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/)

#### Returns

[Section titled “Returns”](#returns-56)

[`RunGameboardActorTargetInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardactortargetinteractionresult/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-32)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`interactActorTarget`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#interactactortarget)

***

### loadPlan

[Section titled “loadPlan”](#loadplan-1)

> **loadPlan**: (`plan`) => [`GameboardEntityIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardentityindex/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:322](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L322)

Load a plan into the bound world.

#### Parameters

[Section titled “Parameters”](#parameters-55)

##### plan

[Section titled “plan”](#plan-2)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

#### Returns

[Section titled “Returns”](#returns-57)

[`GameboardEntityIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardentityindex/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-33)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`loadPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#loadplan)

***

### mountInterop

[Section titled “mountInterop”](#mountinterop)

> **mountInterop**: <`TEntity`>(`adapter`, `options?`) => [`GameboardEcsMountResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsmountresult/)<`TEntity`>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:422](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L422)

Mount the live runtime snapshot into another ECS/store adapter.

#### Type Parameters

[Section titled “Type Parameters”](#type-parameters)

##### TEntity

[Section titled “TEntity”](#tentity)

`TEntity`

#### Parameters

[Section titled “Parameters”](#parameters-56)

##### adapter

[Section titled “adapter”](#adapter)

[`GameboardEcsAdapter`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsadapter/)<`TEntity`>

##### options?

[Section titled “options?”](#options-48)

[`GameboardRuntimeInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimeinteropoptions/)

#### Returns

[Section titled “Returns”](#returns-58)

[`GameboardEcsMountResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsmountresult/)<`TEntity`>

#### Inherited from

[Section titled “Inherited from”](#inherited-from-34)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`mountInterop`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#mountinterop)

***

### mountScenarioInterop

[Section titled “mountScenarioInterop”](#mountscenariointerop)

> **mountScenarioInterop**: <`TEntity`>(`adapter`, `options?`) => [`GameboardEcsMountResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsmountresult/)<`TEntity`>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:641](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L641)

Mount the original scenario definition into another ECS/store adapter.

#### Type Parameters

[Section titled “Type Parameters”](#type-parameters-1)

##### TEntity

[Section titled “TEntity”](#tentity-1)

`TEntity`

#### Parameters

[Section titled “Parameters”](#parameters-57)

##### adapter

[Section titled “adapter”](#adapter-1)

[`GameboardEcsAdapter`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsadapter/)<`TEntity`>

##### options?

[Section titled “options?”](#options-49)

[`GameboardScenarioInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariointeropoptions/)

#### Returns

[Section titled “Returns”](#returns-59)

[`GameboardEcsMountResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsmountresult/)<`TEntity`>

***

### moveActor

[Section titled “moveActor”](#moveactor)

> **moveActor**: (`actor`, `to`, `options?`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:546](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L546)

Move an actor-backed placement by actor id or entity.

#### Parameters

[Section titled “Parameters”](#parameters-58)

##### actor

[Section titled “actor”](#actor-5)

`string` | `Entity`

##### to

[Section titled “to”](#to-2)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### options?

[Section titled “options?”](#options-50)

[`MoveGameboardActorOptions`](/declarative-hex-worlds/reference/index/type-aliases/movegameboardactoroptions/)

#### Returns

[Section titled “Returns”](#returns-60)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-35)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`moveActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#moveactor)

***

### movement

[Section titled “movement”](#movement)

> `readonly` **movement**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:312](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L312)

Movement actions.

#### advance

[Section titled “advance”](#advance)

> **advance**: (`placement`, `options`) => [`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)

Advance one placement along its requested path.

##### Parameters

[Section titled “Parameters”](#parameters-59)

###### placement

[Section titled “placement”](#placement-4)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-51)

[`AdvanceGameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardmovementoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-61)

[`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)

#### clear

[Section titled “clear”](#clear-1)

> **clear**: (`placement`) => `Entity`

Clear active movement path state for a placement.

##### Parameters

[Section titled “Parameters”](#parameters-60)

###### placement

[Section titled “placement”](#placement-5)

`string` | `Entity`

##### Returns

[Section titled “Returns”](#returns-62)

`Entity`

#### reachable

[Section titled “reachable”](#reachable)

> **reachable**: (`placement`, `options`) => [`GameboardReachableTile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardreachabletile/)\[]

Return tiles reachable by one movement agent.

##### Parameters

[Section titled “Parameters”](#parameters-61)

###### placement

[Section titled “placement”](#placement-6)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-52)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-63)

[`GameboardReachableTile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardreachabletile/)\[]

#### requestMove

[Section titled “requestMove”](#requestmove)

> **requestMove**: (`placement`, `destination`, `options`) => [`GameboardMovementRequestResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementrequestresult/)

Request movement to a destination.

##### Parameters

[Section titled “Parameters”](#parameters-62)

###### placement

[Section titled “placement”](#placement-7)

`string` | `Entity`

###### destination

[Section titled “destination”](#destination)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

###### options?

[Section titled “options?”](#options-53)

[`GameboardMovementPathRequestOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementpathrequestoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-64)

[`GameboardMovementRequestResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementrequestresult/)

#### resetBudget

[Section titled “resetBudget”](#resetbudget)

> **resetBudget**: (`placement?`, `options`) => readonly `Entity`\[]

Reset movement budget for one or all movement agents.

##### Parameters

[Section titled “Parameters”](#parameters-63)

###### placement?

[Section titled “placement?”](#placement-8)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-54)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-65)

readonly `Entity`\[]

#### runSystem

[Section titled “runSystem”](#runsystem)

> **runSystem**: (`options`) => [`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)\[]

Advance all active movement agents.

##### Parameters

[Section titled “Parameters”](#parameters-64)

###### options?

[Section titled “options?”](#options-55)

[`AdvanceGameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardmovementoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-66)

[`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)\[]

#### setAgent

[Section titled “setAgent”](#setagent)

> **setAgent**: (`placement`, `options`) => `Entity`

Add or update a movement agent on a placement.

##### Parameters

[Section titled “Parameters”](#parameters-65)

###### placement

[Section titled “placement”](#placement-9)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-56)

[`SetGameboardMovementAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardmovementagentoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-67)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-36)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`movement`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#movement)

***

### movePlacement

[Section titled “movePlacement”](#moveplacement-1)

> **movePlacement**: (`placement`, `to`, `options?`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:394](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L394)

Move one placement to a new tile or coordinate-like target.

Use this for actor movement, build previews, temporary markers, and gameplay props that should remain in the same Koota entity.

#### Parameters

[Section titled “Parameters”](#parameters-66)

##### placement

[Section titled “placement”](#placement-10)

`string` | `Entity`

##### to

[Section titled “to”](#to-3)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### options?

[Section titled “options?”](#options-57)

`Omit`<[`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/), `"at"`>

#### Returns

[Section titled “Returns”](#returns-68)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-37)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`movePlacement`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#moveplacement)

***

### patrol

[Section titled “patrol”](#patrol)

> `readonly` **patrol**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:314](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L314)

Patrol actions.

#### advance

[Section titled “advance”](#advance-1)

> **advance**: (`placement`, `options`) => [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)

Advance one patrol agent.

##### Parameters

[Section titled “Parameters”](#parameters-67)

###### placement

[Section titled “placement”](#placement-11)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-58)

[`AdvanceGameboardPatrolOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardpatroloptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-69)

[`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)

#### clear

[Section titled “clear”](#clear-2)

> **clear**: (`placement`) => `Entity`

Remove patrol traits from a placement.

##### Parameters

[Section titled “Parameters”](#parameters-68)

###### placement

[Section titled “placement”](#placement-12)

`string` | `Entity`

##### Returns

[Section titled “Returns”](#returns-70)

`Entity`

#### read

[Section titled “read”](#read-1)

> **read**: () => [`GameboardPatrolSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/)\[]

Read all patrol snapshots.

##### Returns

[Section titled “Returns”](#returns-71)

[`GameboardPatrolSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/)\[]

#### run

[Section titled “run”](#run)

> **run**: (`options`) => [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)\[]

Advance every patrol agent in the world.

##### Parameters

[Section titled “Parameters”](#parameters-69)

###### options?

[Section titled “options?”](#options-59)

[`AdvanceGameboardPatrolOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardpatroloptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-72)

[`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)\[]

#### set

[Section titled “set”](#set)

> **set**: (`placement`, `options`) => `Entity`

Attach or replace a patrol agent.

##### Parameters

[Section titled “Parameters”](#parameters-70)

###### placement

[Section titled “placement”](#placement-13)

`string` | `Entity`

###### options

[Section titled “options”](#options-60)

[`SetGameboardPatrolAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardpatrolagentoptions/)

##### Returns

[Section titled “Returns”](#returns-73)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-38)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`patrol`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#patrol)

***

### patrolRoutes?

[Section titled “patrolRoutes?”](#patrolroutes)

> `readonly` `optional` **patrolRoutes?**: `GameboardPatrolRouteSet`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:629](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L629)

Scenario patrol routes planned during startup.

***

### plan

[Section titled “plan”](#plan-3)

> **plan**: () => [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:324](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L324)

Project the live world to a renderable plan.

#### Returns

[Section titled “Returns”](#returns-74)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-39)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`plan`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#plan)

***

### planActorTargetCommand

[Section titled “planActorTargetCommand”](#planactortargetcommand)

> **planActorTargetCommand**: (`options`) => [`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:578](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L578)

Plan a command against the selected actor target.

#### Parameters

[Section titled “Parameters”](#parameters-71)

##### options

[Section titled “options”](#options-61)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

#### Returns

[Section titled “Returns”](#returns-75)

[`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-40)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`planActorTargetCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#planactortargetcommand)

***

### planCommand

[Section titled “planCommand”](#plancommand)

> **planCommand**: (`target`, `options?`) => [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:573](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L573)

Plan a command from a renderer or gameplay target.

#### Parameters

[Section titled “Parameters”](#parameters-72)

##### target

[Section titled “target”](#target-4)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

##### options?

[Section titled “options?”](#options-62)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/)

#### Returns

[Section titled “Returns”](#returns-76)

[`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-41)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`planCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#plancommand)

***

### planPatrolRoute

[Section titled “planPatrolRoute”](#planpatrolroute)

> **planPatrolRoute**: (`options`) => `GameboardPatrolRoutePlan`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:435](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L435)

Plan one patrol route from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-73)

##### options

[Section titled “options”](#options-63)

`GameboardPatrolRouteOptions`

#### Returns

[Section titled “Returns”](#returns-77)

`GameboardPatrolRoutePlan`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-42)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`planPatrolRoute`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#planpatrolroute)

***

### planPatrolRoutes

[Section titled “planPatrolRoutes”](#planpatrolroutes)

> **planPatrolRoutes**: (`options`) => `GameboardPatrolRouteSet`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:437](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L437)

Plan a patrol route set from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-74)

##### options

[Section titled “options”](#options-64)

`GameboardPatrolRouteSetOptions`

#### Returns

[Section titled “Returns”](#returns-78)

`GameboardPatrolRouteSet`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-43)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`planPatrolRoutes`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#planpatrolroutes)

***

### planSpawnGroups

[Section titled “planSpawnGroups”](#planspawngroups)

> **planSpawnGroups**: (`options`) => `GameboardSpawnGroupPlan`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:433](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L433)

Plan spawn groups from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-75)

##### options

[Section titled “options”](#options-65)

`GameboardSpawnGroupOptions`

#### Returns

[Section titled “Returns”](#returns-79)

`GameboardSpawnGroupPlan`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-44)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`planSpawnGroups`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#planspawngroups)

***

### previewCommand

[Section titled “previewCommand”](#previewcommand)

> **previewCommand**: (`commandOrTarget`, `options?`) => [`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:582](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L582)

Preview command execution without mutating state.

#### Parameters

[Section titled “Parameters”](#parameters-76)

##### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-5)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

##### options?

[Section titled “options?”](#options-66)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/)

#### Returns

[Section titled “Returns”](#returns-80)

[`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-45)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`previewCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#previewcommand)

***

### questEntities

[Section titled “questEntities”](#questentities)

> `readonly` **questEntities**: `Readonly`<`Record`<`string`, `Entity`>>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:625](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L625)

Scenario quest entity index by quest id.

***

### quests

[Section titled “quests”](#quests)

> `readonly` **quests**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:316](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L316)

Quest actions.

#### advance

[Section titled “advance”](#advance-2)

> **advance**: (`quest`, `options`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

Advance one quest entity.

##### Parameters

[Section titled “Parameters”](#parameters-77)

###### quest

[Section titled “quest”](#quest-2)

`string` | `Entity`

###### options?

[Section titled “options?”](#options-67)

[`AdvanceGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardquestoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-81)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

#### advanceAll

[Section titled “advanceAll”](#advanceall)

> **advanceAll**: (`options`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Advance every quest entity.

##### Parameters

[Section titled “Parameters”](#parameters-78)

###### options?

[Section titled “options?”](#options-68)

[`AdvanceGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardquestoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-82)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

#### find

[Section titled “find”](#find)

> **find**: (`quest`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/) | `undefined`

Find one quest snapshot.

##### Parameters

[Section titled “Parameters”](#parameters-79)

###### quest

[Section titled “quest”](#quest-3)

`string` | `Entity`

##### Returns

[Section titled “Returns”](#returns-83)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/) | `undefined`

#### read

[Section titled “read”](#read-2)

> **read**: () => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Read all quest snapshots.

##### Returns

[Section titled “Returns”](#returns-84)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

#### spawn

[Section titled “spawn”](#spawn-1)

> **spawn**: (`definition`, `options`) => `Entity`

Spawn a quest entity.

##### Parameters

[Section titled “Parameters”](#parameters-80)

###### definition

[Section titled “definition”](#definition)

[`GameboardQuestDefinition`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestdefinition/)

###### options?

[Section titled “options?”](#options-69)

[`SpawnGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardquestoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-85)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-46)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`quests`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#quests)

***

### readActors

[Section titled “readActors”](#readactors)

> **readActors**: () => [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:537](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L537)

Read all registered actors joined with their placement and tile records.

#### Returns

[Section titled “Returns”](#returns-86)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-47)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`readActors`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#readactors)

***

### readActorsForTile

[Section titled “readActorsForTile”](#readactorsfortile)

> **readActorsForTile**: (`coordinates`) => [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:544](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L544)

Read registered actors whose placement origin is one tile.

Use this for hover cards, collision probes, encounter checks, and external ECS sync when a game needs actor semantics instead of raw placements.

#### Parameters

[Section titled “Parameters”](#parameters-81)

##### coordinates

[Section titled “coordinates”](#coordinates-2)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns-87)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-48)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`readActorsForTile`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#readactorsfortile)

***

### readPlacementOccupancy

[Section titled “readPlacementOccupancy”](#readplacementoccupancy)

> **readPlacementOccupancy**: () => [`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:351](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L351)

Read every placement footprint currently reserving or blocking tiles.

The returned records include origin and occupied tile metadata, so UI and pathfinding bridges can reason about multi-hex structures and blockers.

#### Returns

[Section titled “Returns”](#returns-88)

[`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-49)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`readPlacementOccupancy`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#readplacementoccupancy)

***

### readPlacementOccupancyForTile

[Section titled “readPlacementOccupancyForTile”](#readplacementoccupancyfortile)

> **readPlacementOccupancyForTile**: (`coordinates`) => [`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:358](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L358)

Read occupancy records for one tile.

Prefer this over filtering `readPlacementOccupancy()` in UI panels, collision probes, and external ECS bridges that only need one hex.

#### Parameters

[Section titled “Parameters”](#parameters-82)

##### coordinates

[Section titled “coordinates”](#coordinates-3)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns-89)

[`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-50)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`readPlacementOccupancyForTile`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#readplacementoccupancyfortile)

***

### readPlacements

[Section titled “readPlacements”](#readplacements)

> **readPlacements**: () => `object`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:337](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L337)

Read serializable placement records from live state.

Use this for save data, editor panels, renderer diffing, and external ECS mirrors that do not need raw Koota relation stores.

#### Returns

[Section titled “Returns”](#returns-90)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-51)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`readPlacements`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#readplacements)

***

### readPlacementsForTile

[Section titled “readPlacementsForTile”](#readplacementsfortile)

> **readPlacementsForTile**: (`coordinates`) => `object`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:344](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L344)

Read serializable placement records that occupy one tile.

This includes placements whose multi-tile footprint covers the tile, not only placements whose canonical origin is the tile.

#### Parameters

[Section titled “Parameters”](#parameters-83)

##### coordinates

[Section titled “coordinates”](#coordinates-4)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns-91)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-52)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`readPlacementsForTile`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#readplacementsfortile)

***

### readQuests

[Section titled “readQuests”](#readquests)

> **readQuests**: () => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:564](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L564)

Read all quest snapshots from live state for HUDs, saves, and tests.

#### Returns

[Section titled “Returns”](#returns-92)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-53)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`readQuests`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#readquests)

***

### registerActor

[Section titled “registerActor”](#registeractor)

> **registerActor**: (`placement`, `options`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:528](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L528)

Attach actor state to an existing placement.

Register existing placements when a neutral prop, marker, structure, or externally declared piece becomes selectable, interactive, hostile, or quest-addressable after startup.

#### Parameters

[Section titled “Parameters”](#parameters-84)

##### placement

[Section titled “placement”](#placement-14)

`string` | `Entity`

##### options

[Section titled “options”](#options-70)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/)

#### Returns

[Section titled “Returns”](#returns-93)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-54)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`registerActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#registeractor)

***

### removePlacement

[Section titled “removePlacement”](#removeplacement-1)

> **removePlacement**: (`placement`) => `boolean`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:404](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L404)

Remove one placement entity and its placement relations from the live world.

Returns `false` when the entity or placement id cannot be found.

#### Parameters

[Section titled “Parameters”](#parameters-85)

##### placement

[Section titled “placement”](#placement-15)

`string` | `Entity`

#### Returns

[Section titled “Returns”](#returns-94)

`boolean`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-55)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`removePlacement`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#removeplacement)

***

### scenarioLayoutArchetypes?

[Section titled “scenarioLayoutArchetypes?”](#scenariolayoutarchetypes)

> `readonly` `optional` **scenarioLayoutArchetypes?**: `Readonly`<`Record`<`string`, [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)>>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:631](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L631)

Layout archetypes declared by the scenario recipe.

***

### scenarioPieceRegistry?

[Section titled “scenarioPieceRegistry?”](#scenariopieceregistry)

> `readonly` `optional` **scenarioPieceRegistry?**: [`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:633](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L633)

Piece registry declared by the scenario recipe.

***

### scenarioRuntime

[Section titled “scenarioRuntime”](#scenarioruntime)

> `readonly` **scenarioRuntime**: [`GameboardScenarioRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenarioruntime/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:621](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L621)

Scenario runtime produced by `createGameboardWorldFromScenario`.

***

### selectActors

[Section titled “selectActors”](#selectactors)

> **selectActors**: (`options?`) => [`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:416](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L416)

Select actors from live state using actor-aware filters.

#### Parameters

[Section titled “Parameters”](#parameters-86)

##### options?

[Section titled “options?”](#options-71)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/)

#### Returns

[Section titled “Returns”](#returns-95)

[`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-56)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`selectActors`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#selectactors)

***

### selectPieces

[Section titled “selectPieces”](#selectpieces)

> **selectPieces**: (`registry`, `selection?`) => [`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:482](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L482)

Select declarations from a custom piece registry.

#### Parameters

[Section titled “Parameters”](#parameters-87)

##### registry

[Section titled “registry”](#registry-5)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### selection?

[Section titled “selection?”](#selection)

[`GameboardPieceRegistrySelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryselection/)

#### Returns

[Section titled “Returns”](#returns-96)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-57)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`selectPieces`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#selectpieces)

***

### selectSpawnLocations

[Section titled “selectSpawnLocations”](#selectspawnlocations)

> **selectSpawnLocations**: (`options`) => [`SpawnLocation`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocation/)\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:431](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L431)

Select deterministic spawn locations from the live projected world.

#### Parameters

[Section titled “Parameters”](#parameters-88)

##### options

[Section titled “options”](#options-72)

`GameboardSpawnLocationOptions`

#### Returns

[Section titled “Returns”](#returns-97)

[`SpawnLocation`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocation/)\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-58)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`selectSpawnLocations`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#selectspawnlocations)

***

### snapshot

[Section titled “snapshot”](#snapshot)

> **snapshot**: (`options?`) => [`GameboardRuntimeSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimesnapshot/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:330](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L330)

Read a serializable runtime snapshot.

#### Parameters

[Section titled “Parameters”](#parameters-89)

##### options?

[Section titled “options?”](#options-73)

[`GameboardRuntimeSnapshotOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimesnapshotoptions/)

#### Returns

[Section titled “Returns”](#returns-98)

[`GameboardRuntimeSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimesnapshot/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-59)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`snapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#snapshot)

***

### spawnActor

[Section titled “spawnActor”](#spawnactor)

> **spawnActor**: (`options`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:520](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L520)

Spawn an actor-backed placement.

#### Parameters

[Section titled “Parameters”](#parameters-90)

##### options

[Section titled “options”](#options-74)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/)

#### Returns

[Section titled “Returns”](#returns-99)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-60)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`spawnActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#spawnactor)

***

### spawnGroups?

[Section titled “spawnGroups?”](#spawngroups)

> `readonly` `optional` **spawnGroups?**: `GameboardSpawnGroupPlan`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:627](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L627)

Scenario spawn groups planned during startup.

***

### spawnLayoutFill

[Section titled “spawnLayoutFill”](#spawnlayoutfill)

> **spawnLayoutFill**: (`options`) => `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:455](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L455)

Spawn a generated layout fill into the live world.

#### Parameters

[Section titled “Parameters”](#parameters-91)

##### options

[Section titled “options”](#options-75)

[`GameboardLayoutFillOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfilloptions/)

#### Returns

[Section titled “Returns”](#returns-100)

`Entity`\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-61)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`spawnLayoutFill`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#spawnlayoutfill)

***

### spawnLayoutPlacements

[Section titled “spawnLayoutPlacements”](#spawnlayoutplacements)

> **spawnLayoutPlacements**: (`options`) => `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:453](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L453)

Spawn explicit layout placements into the live world.

#### Parameters

[Section titled “Parameters”](#parameters-92)

##### options

[Section titled “options”](#options-76)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-101)

`Entity`\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-62)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`spawnLayoutPlacements`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#spawnlayoutplacements)

***

### spawnPiece

[Section titled “spawnPiece”](#spawnpiece)

> **spawnPiece**: (`piece`, `options?`) => `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:472](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L472)

Spawn one declared piece into the live world.

#### Parameters

[Section titled “Parameters”](#parameters-93)

##### piece

[Section titled “piece”](#piece-3)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)

##### options?

[Section titled “options?”](#options-77)

[`GameboardPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-102)

`Entity`\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-63)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`spawnPiece`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#spawnpiece)

***

### spawnPieceFills

[Section titled “spawnPieceFills”](#spawnpiecefills)

> **spawnPieceFills**: (`registry`, `fills`, `options?`) => `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:509](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L509)

Spawn generated piece fills into the live world.

#### Parameters

[Section titled “Parameters”](#parameters-94)

##### registry

[Section titled “registry”](#registry-6)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

##### fills

[Section titled “fills”](#fills-2)

readonly [`SeededGameboardPieceFillOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefilloptions/)\[]

##### options?

[Section titled “options?”](#options-78)

[`InspectSeededGameboardPieceFillsOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectseededgameboardpiecefillsoptions/)

#### Returns

[Section titled “Returns”](#returns-103)

`Entity`\[]

#### Inherited from

[Section titled “Inherited from”](#inherited-from-64)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`spawnPieceFills`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#spawnpiecefills)

***

### spawnPlacement

[Section titled “spawnPlacement”](#spawnplacement-1)

> **spawnPlacement**: (`options`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:376](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L376)

Spawn one renderable placement into the live world.

Pass `occupancyGuard: true` when the spawn should fail instead of overlapping an existing blocker or missing footprint tile.

#### Parameters

[Section titled “Parameters”](#parameters-95)

##### options

[Section titled “options”](#options-79)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-104)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-65)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`spawnPlacement`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#spawnplacement)

***

### spawnQuest

[Section titled “spawnQuest”](#spawnquest)

> **spawnQuest**: (`definition`, `options?`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:557](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L557)

Spawn a quest definition into the live world.

Quest objectives can reference actor ids, placement ids, and tile keys, so scenario and runtime-created quests use the same progression surface.

#### Parameters

[Section titled “Parameters”](#parameters-96)

##### definition

[Section titled “definition”](#definition-1)

[`GameboardQuestDefinition`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestdefinition/)

##### options?

[Section titled “options?”](#options-80)

[`SpawnGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardquestoptions/)

#### Returns

[Section titled “Returns”](#returns-105)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-66)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`spawnQuest`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#spawnquest)

***

### summarizePlan

[Section titled “summarizePlan”](#summarizeplan)

> **summarizePlan**: (`options?`) => [`GameboardPlanSummary`](/declarative-hex-worlds/reference/index/interfaces/gameboardplansummary/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:326](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L326)

Summarize the live projected plan for editor, diagnostics, and bridge code.

#### Parameters

[Section titled “Parameters”](#parameters-97)

##### options?

[Section titled “options?”](#options-81)

[`SummarizeGameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/summarizegameboardplanoptions/)

#### Returns

[Section titled “Returns”](#returns-106)

[`GameboardPlanSummary`](/declarative-hex-worlds/reference/index/interfaces/gameboardplansummary/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-67)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`summarizePlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#summarizeplan)

***

### summarizeScenario

[Section titled “summarizeScenario”](#summarizescenario)

> **summarizeScenario**: (`options?`) => [`GameboardScenarioSummary`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosummary/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:639](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L639)

Summarize the original scenario definition, actors, quests, spawns, and routes.

#### Parameters

[Section titled “Parameters”](#parameters-98)

##### options?

[Section titled “options?”](#options-82)

[`SummarizeGameboardScenarioOptions`](/declarative-hex-worlds/reference/index/interfaces/summarizegameboardscenariooptions/)

#### Returns

[Section titled “Returns”](#returns-107)

[`GameboardScenarioSummary`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosummary/)

***

### systems

[Section titled “systems”](#systems)

> `readonly` **systems**: `object`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:320](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L320)

System dispatch/tick actions.

#### dispatchActorTargetCommand

[Section titled “dispatchActorTargetCommand”](#dispatchactortargetcommand-1)

> **dispatchActorTargetCommand**: (`options`, `commandOptions`) => [`DispatchGameboardActorTargetCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardactortargetcommandresult/)

Select an actor target, then execute its planned command.

##### Parameters

[Section titled “Parameters”](#parameters-99)

###### options

[Section titled “options”](#options-83)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

###### commandOptions?

[Section titled “commandOptions?”](#commandoptions-1)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-108)

[`DispatchGameboardActorTargetCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardactortargetcommandresult/)

#### dispatchCommand

[Section titled “dispatchCommand”](#dispatchcommand-1)

> **dispatchCommand**: (`commandOrTarget`, `options`) => [`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

Execute one command and emit dispatch event records.

##### Parameters

[Section titled “Parameters”](#parameters-100)

###### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-6)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

###### options?

[Section titled “options?”](#options-84)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-109)

[`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

#### interact

[Section titled “interact”](#interact-1)

> **interact**: (`commandOrTarget`, `options`) => [`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/)

Dispatch a command and optionally tick systems.

##### Parameters

[Section titled “Parameters”](#parameters-101)

###### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-7)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

###### options?

[Section titled “options?”](#options-85)

[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-110)

[`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/)

#### interactActorTarget

[Section titled “interactActorTarget”](#interactactortarget-1)

> **interactActorTarget**: (`options`, `interactionOptions`) => [`RunGameboardActorTargetInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardactortargetinteractionresult/)

Target an actor, dispatch the command, and optionally tick systems.

##### Parameters

[Section titled “Parameters”](#parameters-102)

###### options

[Section titled “options”](#options-86)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

###### interactionOptions?

[Section titled “interactionOptions?”](#interactionoptions-1)

[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-111)

[`RunGameboardActorTargetInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardactortargetinteractionresult/)

#### run

[Section titled “run”](#run-1)

> **run**: (`options`) => [`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

Run enabled patrol, movement, and quest systems for one tick.

##### Parameters

[Section titled “Parameters”](#parameters-103)

###### options?

[Section titled “options?”](#options-87)

[`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/) = `{}`

##### Returns

[Section titled “Returns”](#returns-112)

[`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-68)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`systems`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#systems)

***

### tick

[Section titled “tick”](#tick)

> **tick**: (`options?`) => [`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:612](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L612)

Run enabled systems for one game-loop tick.

#### Parameters

[Section titled “Parameters”](#parameters-104)

##### options?

[Section titled “options?”](#options-88)

[`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

#### Returns

[Section titled “Returns”](#returns-113)

[`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-69)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`tick`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#tick)

***

### updateActor

[Section titled “updateActor”](#updateactor)

> **updateActor**: (`actor`, `options`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:533](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L533)

Update actor state while preserving omitted fields and placement binding.

#### Parameters

[Section titled “Parameters”](#parameters-105)

##### actor

[Section titled “actor”](#actor-6)

`string` | `Entity`

##### options

[Section titled “options”](#options-89)

[`UpdateGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardactoroptions/)

#### Returns

[Section titled “Returns”](#returns-114)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-70)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`updateActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#updateactor)

***

### updatePlacement

[Section titled “updatePlacement”](#updateplacement-1)

> **updatePlacement**: (`placement`, `options`) => `Entity`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:384](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L384)

Update one placement in the live world while preserving omitted fields.

The helper refreshes placement classification and footprint relations when fields such as coordinates, kind, layer, footprint, tags, or blocking behavior change.

#### Parameters

[Section titled “Parameters”](#parameters-106)

##### placement

[Section titled “placement”](#placement-16)

`string` | `Entity`

##### options

[Section titled “options”](#options-90)

[`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-115)

`Entity`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-71)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`updatePlacement`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#updateplacement)

***

### validationPlan

[Section titled “validationPlan”](#validationplan)

> **validationPlan**: () => [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:328](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L328)

Project the live world to a plan shape suitable for validation.

#### Returns

[Section titled “Returns”](#returns-116)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

#### Inherited from

[Section titled “Inherited from”](#inherited-from-72)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`validationPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#validationplan)

***

### world

[Section titled “world”](#world)

> `readonly` **world**: `World`

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:306](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L306)

Bound Koota world.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-73)

[`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/).[`world`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/#world)

# GameboardScenarioInteropOptions

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:458](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L458)

Options for scenario interop snapshots.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/)

## Properties

[Section titled “Properties”](#properties)

### includeActors?

[Section titled “includeActors?”](#includeactors)

> `optional` **includeActors?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:460](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L460)

Include resolved actor entities and relations.

***

### includePatrolRoutes?

[Section titled “includePatrolRoutes?”](#includepatrolroutes)

> `optional` **includePatrolRoutes?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:466](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L466)

Include patrol-route entities and relations.

***

### includePlacements?

[Section titled “includePlacements?”](#includeplacements)

> `optional` **includePlacements?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:450](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L450)

Include placement entities and relations. Defaults to true.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/).[`includePlacements`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/#includeplacements)

***

### includeQuests?

[Section titled “includeQuests?”](#includequests)

> `optional` **includeQuests?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:462](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L462)

Include quest entities and relations.

***

### includeSpawnGroups?

[Section titled “includeSpawnGroups?”](#includespawngroups)

> `optional` **includeSpawnGroups?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:464](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L464)

Include spawn-group entities and relations.

***

### spawnLocations?

[Section titled “spawnLocations?”](#spawnlocations)

> `optional` **spawnLocations?**: `Omit`<[`SpawnLocationOptions`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocationoptions/), `"shape"`>

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:452](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L452)

Optional spawn-location generation options.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/).[`spawnLocations`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/#spawnlocations)

# GameboardScenarioPatrolRoute

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L86)

Patrol route rule embedded in a scenario.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardPatrolRouteRule`](/declarative-hex-worlds/reference/gameboard/navigation/type-aliases/gameboardpatrolrouterule/)

## Properties

[Section titled “Properties”](#properties)

### count?

[Section titled “count?”](#count)

> `optional` **count?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts:73](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts#L73)

Requested waypoint count.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

`GameboardPatrolRouteRule.count`

***

### edgePadding?

[Section titled “edgePadding?”](#edgepadding)

> `optional` **edgePadding?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:87](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L87)

Number of outer rings/rows to avoid when selecting automatic candidates.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`SpawnLocationOptions`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocationoptions/).[`edgePadding`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocationoptions/#edgepadding)

***

### elevation?

[Section titled “elevation?”](#elevation)

> `optional` **elevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:89](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L89)

Elevation used when projecting spawn locations to world positions.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`SpawnLocationOptions`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocationoptions/).[`elevation`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocationoptions/#elevation)

***

### excludeTileTags?

[Section titled “excludeTileTags?”](#excludetiletags)

> `optional` **excludeTileTags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts:34](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts#L34)

Tile tags that must all be absent.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

`GameboardPatrolRouteRule.excludeTileTags`

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts:95](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts#L95)

Stable route id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

`GameboardPatrolRouteRule.id`

***

### idPrefix?

[Section titled “idPrefix?”](#idprefix)

> `optional` **idPrefix?**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:91](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L91)

Prefix used for generated spawn ids.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`SpawnLocationOptions`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocationoptions/).[`idPrefix`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocationoptions/#idprefix)

***

### loop?

[Section titled “loop?”](#loop)

> `optional` **loop?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts:85](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts#L85)

Whether the patrol returns to its first waypoint.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

`GameboardPatrolRouteRule.loop`

***

### maxElevation?

[Section titled “maxElevation?”](#maxelevation)

> `optional` **maxElevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts:30](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts#L30)

Maximum candidate elevation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

`GameboardPatrolRouteRule.maxElevation`

***

### minDistance?

[Section titled “minDistance?”](#mindistance)

> `optional` **minDistance?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:85](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L85)

Minimum axial distance between returned spawn coordinates.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`SpawnLocationOptions`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocationoptions/).[`minDistance`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocationoptions/#mindistance)

***

### minElevation?

[Section titled “minElevation?”](#minelevation)

> `optional` **minElevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts:28](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts#L28)

Minimum candidate elevation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

`GameboardPatrolRouteRule.minElevation`

***

### profile?

[Section titled “profile?”](#profile)

> `optional` **profile?**: [`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts:24](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts#L24)

Navigation profile used to reject blocked candidates.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

`GameboardPatrolRouteRule.profile`

***

### requireCompleteRoute?

[Section titled “requireCompleteRoute?”](#requirecompleteroute)

> `optional` **requireCompleteRoute?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts:87](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts#L87)

Treat missing route segments as errors.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

`GameboardPatrolRouteRule.requireCompleteRoute`

***

### routeProfile?

[Section titled “routeProfile?”](#routeprofile)

> `optional` **routeProfile?**: [`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts:83](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts#L83)

Navigation profile used for route segments.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

`GameboardPatrolRouteRule.routeProfile`

***

### seed?

[Section titled “seed?”](#seed)

> `optional` **seed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/grid.ts:79](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/grid.ts#L79)

Seed used when candidate order must be randomized.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`SpawnLocationOptions`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocationoptions/).[`seed`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocationoptions/#seed)

***

### start?

[Section titled “start?”](#start)

> `optional` **start?**: `string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts:75](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts#L75)

Explicit start tile, actor, or key.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-14)

`GameboardPatrolRouteRule.start`

***

### startGroupId?

[Section titled “startGroupId?”](#startgroupid)

> `optional` **startGroupId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts:77](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts#L77)

Spawn group id used for the start waypoint.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-15)

`GameboardPatrolRouteRule.startGroupId`

***

### startLocationIndex?

[Section titled “startLocationIndex?”](#startlocationindex)

> `optional` **startLocationIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts:79](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/patrol-routes.ts#L79)

Location index within the start spawn group.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-16)

`GameboardPatrolRouteRule.startLocationIndex`

***

### terrain?

[Section titled “terrain?”](#terrain)

> `optional` **terrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/) | readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts:26](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts#L26)

Allowed terrain for spawn candidates.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-17)

`GameboardPatrolRouteRule.terrain`

***

### tileTags?

[Section titled “tileTags?”](#tiletags)

> `optional` **tileTags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts:32](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts#L32)

Tile tags that must all be present.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-18)

`GameboardPatrolRouteRule.tileTags`

# GameboardScenarioRuntime

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L134)

Runtime objects produced after compiling and spawning a scenario.

## Properties

[Section titled “Properties”](#properties)

### actorEntities

[Section titled “actorEntities”](#actorentities)

> **actorEntities**: `Readonly`<`Record`<`string`, `Entity`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:146](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L146)

Spawned actor entities keyed by actor id.

***

### actors

[Section titled “actors”](#actors)

> **actors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:150](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L150)

Actor snapshots after scenario spawn.

***

### patrolRoutes?

[Section titled “patrolRoutes?”](#patrolroutes)

> `optional` **patrolRoutes?**: `GameboardPatrolRouteSet`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:142](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L142)

Planned patrol routes, when configured.

***

### plan

[Section titled “plan”](#plan)

> **plan**: [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:138](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L138)

Compiled gameboard plan.

***

### questEntities

[Section titled “questEntities”](#questentities)

> **questEntities**: `Readonly`<`Record`<`string`, `Entity`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:148](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L148)

Spawned quest entities keyed by quest id.

***

### quests

[Section titled “quests”](#quests)

> **quests**: readonly [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:152](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L152)

Quest snapshots after scenario spawn.

***

### scenario

[Section titled “scenario”](#scenario)

> **scenario**: [`GameboardScenario`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenario/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L136)

Scenario definition used to create the runtime.

***

### spawnGroups?

[Section titled “spawnGroups?”](#spawngroups)

> `optional` **spawnGroups?**: `GameboardSpawnGroupPlan`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:140](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L140)

Planned spawn groups, when configured.

***

### world

[Section titled “world”](#world)

> **world**: `World`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:144](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L144)

Koota world containing board, actor, quest, movement, and patrol state.

# GameboardScenarioSimulationActorExpectation

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:502](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L502)

Expected final actor state in a simulation report.

## Properties

[Section titled “Properties”](#properties)

### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:504](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L504)

Actor id to inspect.

***

### assetId?

[Section titled “assetId?”](#assetid)

> `optional` **assetId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:528](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L528)

Expected actor placement asset id.

***

### blocksMovement?

[Section titled “blocksMovement?”](#blocksmovement)

> `optional` **blocksMovement?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:516](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L516)

Expected movement-blocking flag.

***

### exists?

[Section titled “exists?”](#exists)

> `optional` **exists?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:506](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L506)

Whether the actor is expected to exist.

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:510](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L510)

Expected actor faction.

***

### hostile?

[Section titled “hostile?”](#hostile)

> `optional` **hostile?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:514](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L514)

Expected hostile flag.

***

### interactive?

[Section titled “interactive?”](#interactive)

> `optional` **interactive?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:518](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L518)

Expected interactive flag.

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:508](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L508)

Expected actor kind.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>>

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:522](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L522)

Actor metadata entries that must match.

***

### placementId?

[Section titled “placementId?”](#placementid)

> `optional` **placementId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:526](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L526)

Expected actor placement id.

***

### tags?

[Section titled “tags?”](#tags)

> `optional` **tags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:520](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L520)

Actor tags that must be present.

***

### team?

[Section titled “team?”](#team)

> `optional` **team?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:512](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L512)

Expected actor team.

***

### tileKey?

[Section titled “tileKey?”](#tilekey)

> `optional` **tileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:524](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L524)

Expected actor tile key.

# GameboardScenarioSimulationActorRecord

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:195](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L195)

Final actor record in a simulation report.

## Properties

[Section titled “Properties”](#properties)

### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:197](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L197)

Actor id.

***

### blocksMovement

[Section titled “blocksMovement”](#blocksmovement)

> **blocksMovement**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:207](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L207)

Whether the actor blocks movement.

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:201](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L201)

Actor faction.

***

### hostile

[Section titled “hostile”](#hostile)

> **hostile**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:205](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L205)

Whether the actor is generally hostile.

***

### interactive

[Section titled “interactive”](#interactive)

> **interactive**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:209](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L209)

Whether the actor can be interacted with.

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/)

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:199](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L199)

Actor kind.

***

### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Readonly`<`Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>>

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:213](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L213)

Serializable actor metadata.

***

### placement

[Section titled “placement”](#placement)

> **placement**: [`GameboardScenarioSimulationPlacementRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationplacementrecord/)

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:215](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L215)

Final placement record for the actor.

***

### tags

[Section titled “tags”](#tags)

> **tags**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:211](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L211)

Actor tags.

***

### team?

[Section titled “team?”](#team)

> `optional` **team?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:203](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L203)

Actor team.

# GameboardScenarioSimulationActorTargetCommandStep

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:118](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L118)

Selects an actor target, dispatches its planned command, and optionally runs systems.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"actor-target-command"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:121](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L121)

Step discriminator.

***

### command?

[Section titled “command?”](#command)

> `optional` **command?**: `Omit`<[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/), `"systems"` | `"handlers"`>

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:133](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L133)

Command execution options excluding systems and handlers.

***

### handler?

[Section titled “handler?”](#handler)

> `optional` **handler?**: `"remove-target-actor"` | `"remove-target-placement"` | `"mark-target-interacted"` | `"default-rpg"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:135](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L135)

Single built-in command handler preset.

***

### handlerOptions?

[Section titled “handlerOptions?”](#handleroptions)

> `optional` **handlerOptions?**: [`CreateGameboardInteractionHandlerPresetOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardinteractionhandlerpresetoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:139](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L139)

Options for built-in command handler presets.

***

### handlers?

[Section titled “handlers?”](#handlers)

> `optional` **handlers?**: readonly (`"remove-target-actor"` | `"remove-target-placement"` | `"mark-target-interacted"` | `"default-rpg"`)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:137](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L137)

Built-in command handler presets.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L86)

Optional stable step id used by reports and expectations.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`id`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#id)

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L88)

Human-readable step label for reports.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`label`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#label)

***

### requireReachable?

[Section titled “requireReachable?”](#requirereachable)

> `optional` **requireReachable?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:127](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L127)

Require the selected target to be reachable.

***

### sourceActor?

[Section titled “sourceActor?”](#sourceactor)

> `optional` **sourceActor?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:123](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L123)

Source actor id.

***

### systems?

[Section titled “systems?”](#systems)

> `optional` **systems?**: `false` | [`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:141](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L141)

Systems to run after command dispatch, or false to skip.

***

### targetActorId?

[Section titled “targetActorId?”](#targetactorid)

> `optional` **targetActorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:125](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L125)

Optional exact target actor id.

***

### targeting?

[Section titled “targeting?”](#targeting)

> `optional` **targeting?**: `Partial`<`Omit`<[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/), `"sourceActor"` | `"targetActorId"` | `"requireReachable"`>>

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:129](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L129)

Actor-targeting filters and path options.

# GameboardScenarioSimulationActorTargetRecord

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:814](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L814)

Serializable actor target summary.

## Properties

[Section titled “Properties”](#properties)

### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:816](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L816)

Actor id.

***

### approach

[Section titled “approach”](#approach)

> **approach**: [`GameboardActorTargetApproach`](/declarative-hex-worlds/reference/index/type-aliases/gameboardactortargetapproach/) | `"self"` | `"none"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:834](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L834)

Approach policy selected for the target.

***

### approachTileKey?

[Section titled “approachTileKey?”](#approachtilekey)

> `optional` **approachTileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:836](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L836)

Approach tile key when one was selected.

***

### commandActorId?

[Section titled “commandActorId?”](#commandactorid)

> `optional` **commandActorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:860](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L860)

Planned command actor id.

***

### commandCanExecute

[Section titled “commandCanExecute”](#commandcanexecute)

> **commandCanExecute**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:852](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L852)

Whether the planned command can execute.

***

### commandIntent

[Section titled “commandIntent”](#commandintent)

> **commandIntent**: [`GameboardInteractionIntent`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionintent/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:850](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L850)

Planned command intent.

***

### commandKind

[Section titled “commandKind”](#commandkind)

> **commandKind**: [`GameboardInteractionCommandKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandkind/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:848](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L848)

Planned command kind.

***

### commandPlacementId?

[Section titled “commandPlacementId?”](#commandplacementid)

> `optional` **commandPlacementId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:858](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L858)

Planned command placement id.

***

### commandReason?

[Section titled “commandReason?”](#commandreason)

> `optional` **commandReason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:854](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L854)

Planned command failure reason.

***

### commandTileKey?

[Section titled “commandTileKey?”](#commandtilekey)

> `optional` **commandTileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:856](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L856)

Planned command tile key.

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:824](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L824)

Actor faction.

***

### hostile

[Section titled “hostile”](#hostile)

> **hostile**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:828](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L828)

Whether the actor is generally hostile.

***

### hostileToSource?

[Section titled “hostileToSource?”](#hostiletosource)

> `optional` **hostileToSource?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:830](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L830)

Whether the actor is hostile to the source actor.

***

### interactive

[Section titled “interactive”](#interactive)

> **interactive**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:832](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L832)

Whether the actor is interactive.

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:822](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L822)

Actor kind.

***

### pathCost

[Section titled “pathCost”](#pathcost)

> **pathCost**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:844](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L844)

Path cost.

***

### pathFound

[Section titled “pathFound”](#pathfound)

> **pathFound**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:842](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L842)

Whether a path was found.

***

### pathKeys

[Section titled “pathKeys”](#pathkeys)

> **pathKeys**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:846](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L846)

Path tile keys.

***

### placementId

[Section titled “placementId”](#placementid)

> **placementId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:818](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L818)

Placement id for the actor.

***

### reachable

[Section titled “reachable”](#reachable)

> **reachable**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:838](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L838)

Whether a usable approach path was found.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:840](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L840)

Optional unreachable or command reason.

***

### team?

[Section titled “team?”](#team)

> `optional` **team?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:826](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L826)

Actor team.

***

### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:820](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L820)

Actor tile key.

# GameboardScenarioSimulationActorTargetsExpectation

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:356](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L356)

Expected actor-targeting record in a simulation report.

## Properties

[Section titled “Properties”](#properties)

### nearestActorId?

[Section titled “nearestActorId?”](#nearestactorid)

> `optional` **nearestActorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:368](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L368)

Expected nearest target actor id.

***

### nearestApproach?

[Section titled “nearestApproach?”](#nearestapproach)

> `optional` **nearestApproach?**: [`GameboardActorTargetApproach`](/declarative-hex-worlds/reference/index/type-aliases/gameboardactortargetapproach/) | `"self"` | `"none"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:370](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L370)

Expected nearest target approach.

***

### nearestApproachTileKey?

[Section titled “nearestApproachTileKey?”](#nearestapproachtilekey)

> `optional` **nearestApproachTileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:372](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L372)

Expected nearest target approach tile key.

***

### nearestPathCost?

[Section titled “nearestPathCost?”](#nearestpathcost)

> `optional` **nearestPathCost?**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:378](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L378)

Expected nearest target path cost.

***

### nearestPathFound?

[Section titled “nearestPathFound?”](#nearestpathfound)

> `optional` **nearestPathFound?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:376](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L376)

Expected nearest target path-found flag.

***

### nearestPathKeys?

[Section titled “nearestPathKeys?”](#nearestpathkeys)

> `optional` **nearestPathKeys?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:380](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L380)

Expected nearest target path tile keys.

***

### nearestReachable?

[Section titled “nearestReachable?”](#nearestreachable)

> `optional` **nearestReachable?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:374](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L374)

Expected nearest target reachability.

***

### reachableActorIds?

[Section titled “reachableActorIds?”](#reachableactorids)

> `optional` **reachableActorIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:366](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L366)

Exact reachable actor ids expected in the report.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:402](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L402)

Expected target report reason.

***

### sourceActorId?

[Section titled “sourceActorId?”](#sourceactorid)

> `optional` **sourceActorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:362](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L362)

Expected source actor id.

***

### stepId?

[Section titled “stepId?”](#stepid)

> `optional` **stepId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:358](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L358)

Step id that should emit the target report.

***

### stepIndex?

[Section titled “stepIndex?”](#stepindex)

> `optional` **stepIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:360](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L360)

Step index that should emit the target report.

***

### targetActorId?

[Section titled “targetActorId?”](#targetactorid)

> `optional` **targetActorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:382](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L382)

Specific target actor id to inspect.

***

### targetActorIds?

[Section titled “targetActorIds?”](#targetactorids)

> `optional` **targetActorIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:364](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L364)

Exact target actor ids expected in the report.

***

### targetApproach?

[Section titled “targetApproach?”](#targetapproach)

> `optional` **targetApproach?**: [`GameboardActorTargetApproach`](/declarative-hex-worlds/reference/index/type-aliases/gameboardactortargetapproach/) | `"self"` | `"none"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:386](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L386)

Expected specific target approach.

***

### targetApproachTileKey?

[Section titled “targetApproachTileKey?”](#targetapproachtilekey)

> `optional` **targetApproachTileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:388](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L388)

Expected specific target approach tile key.

***

### targetCommandCanExecute?

[Section titled “targetCommandCanExecute?”](#targetcommandcanexecute)

> `optional` **targetCommandCanExecute?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:400](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L400)

Expected specific target command executability.

***

### targetCommandIntent?

[Section titled “targetCommandIntent?”](#targetcommandintent)

> `optional` **targetCommandIntent?**: [`GameboardInteractionIntent`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionintent/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:398](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L398)

Expected specific target command intent.

***

### targetCommandKind?

[Section titled “targetCommandKind?”](#targetcommandkind)

> `optional` **targetCommandKind?**: [`GameboardInteractionCommandKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandkind/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:396](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L396)

Expected specific target command kind.

***

### targetPathCost?

[Section titled “targetPathCost?”](#targetpathcost)

> `optional` **targetPathCost?**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:392](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L392)

Expected specific target path cost.

***

### targetPathFound?

[Section titled “targetPathFound?”](#targetpathfound)

> `optional` **targetPathFound?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:390](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L390)

Expected specific target path-found flag.

***

### targetPathKeys?

[Section titled “targetPathKeys?”](#targetpathkeys)

> `optional` **targetPathKeys?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:394](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L394)

Expected specific target path tile keys.

***

### targetReachable?

[Section titled “targetReachable?”](#targetreachable)

> `optional` **targetReachable?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:384](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L384)

Expected specific target reachability.

# GameboardScenarioSimulationActorTargetsRecord

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:786](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L786)

Serializable actor-targeting report with step provenance.

Declared in `script.ts` (not `report.ts`) because it appears in `GameboardScenarioSimulationStepResult`, which the engine produces and the report module consumes.

## Properties

[Section titled “Properties”](#properties)

### nearestTarget?

[Section titled “nearestTarget?”](#nearesttarget)

> `optional` **nearestTarget?**: [`GameboardScenarioSimulationActorTargetRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationactortargetrecord/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:804](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L804)

Nearest or chosen target summary.

***

### reachableActorIds

[Section titled “reachableActorIds”](#reachableactorids)

> **reachableActorIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:802](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L802)

Reachable target actor ids in sorted order.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:808](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L808)

Optional targeting failure reason.

***

### sourceActorId?

[Section titled “sourceActorId?”](#sourceactorid)

> `optional` **sourceActorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:794](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L794)

Source actor id.

***

### sourcePlacementId?

[Section titled “sourcePlacementId?”](#sourceplacementid)

> `optional` **sourcePlacementId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:796](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L796)

Source placement id.

***

### sourceTileKey?

[Section titled “sourceTileKey?”](#sourcetilekey)

> `optional` **sourceTileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:798](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L798)

Source tile key.

***

### stepId?

[Section titled “stepId?”](#stepid)

> `optional` **stepId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:790](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L790)

Authored step id.

***

### stepIndex

[Section titled “stepIndex”](#stepindex)

> **stepIndex**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:788](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L788)

Step index that emitted the actor-target report.

***

### stepLabel?

[Section titled “stepLabel?”](#steplabel)

> `optional` **stepLabel?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:792](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L792)

Authored step label.

***

### targetActorIds

[Section titled “targetActorIds”](#targetactorids)

> **targetActorIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:800](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L800)

All target actor ids in sorted order.

***

### targets

[Section titled “targets”](#targets)

> **targets**: readonly [`GameboardScenarioSimulationActorTargetRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationactortargetrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:806](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L806)

Full target summaries.

# GameboardScenarioSimulationActorTargetsStep

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:147](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L147)

Inspects actor targets without dispatching a command.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"inspect-actor-targets"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:150](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L150)

Step discriminator.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L86)

Optional stable step id used by reports and expectations.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`id`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#id)

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L88)

Human-readable step label for reports.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`label`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#label)

***

### sourceActor?

[Section titled “sourceActor?”](#sourceactor)

> `optional` **sourceActor?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:152](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L152)

Source actor id.

***

### targeting?

[Section titled “targeting?”](#targeting)

> `optional` **targeting?**: `Partial`<`Omit`<[`GameboardActorTargetingOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/), `"sourceActor"`>>

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:154](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L154)

Actor-targeting filters and path options.

# GameboardScenarioSimulationCommandExpectation

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:308](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L308)

Expected command record in a simulation report.

## Properties

[Section titled “Properties”](#properties)

### actorId?

[Section titled “actorId?”](#actorid)

> `optional` **actorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:328](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L328)

Expected command actor id.

***

### canExecute?

[Section titled “canExecute?”](#canexecute)

> `optional` **canExecute?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:320](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L320)

Expected command executability.

***

### effectTypes?

[Section titled “effectTypes?”](#effecttypes)

> `optional` **effectTypes?**: readonly (`"actor-removed"` | `"placement-removed"` | `"actor-updated"` | `"placement-updated"`)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:338](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L338)

Expected command effect types.

***

### handlerId?

[Section titled “handlerId?”](#handlerid)

> `optional` **handlerId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:334](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L334)

Expected handler id.

***

### handlerStatus?

[Section titled “handlerStatus?”](#handlerstatus)

> `optional` **handlerStatus?**: [`GameboardInteractionHandlerStatus`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandlerstatus/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:336](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L336)

Expected handler status.

***

### intent?

[Section titled “intent?”](#intent)

> `optional` **intent?**: [`GameboardInteractionIntent`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionintent/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:316](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L316)

Expected command intent.

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`GameboardInteractionCommandKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandkind/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:314](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L314)

Expected command kind.

***

### placementId?

[Section titled “placementId?”](#placementid)

> `optional` **placementId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:326](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L326)

Expected command placement id.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:322](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L322)

Expected command reason.

***

### sourceActorId?

[Section titled “sourceActorId?”](#sourceactorid)

> `optional` **sourceActorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:330](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L330)

Expected source actor id.

***

### sourcePlacementId?

[Section titled “sourcePlacementId?”](#sourceplacementid)

> `optional` **sourcePlacementId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:332](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L332)

Expected source placement id.

***

### status?

[Section titled “status?”](#status)

> `optional` **status?**: [`GameboardInteractionExecutionStatus`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionexecutionstatus/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:318](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L318)

Expected command status.

***

### stepId?

[Section titled “stepId?”](#stepid)

> `optional` **stepId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:310](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L310)

Step id that should emit the command.

***

### stepIndex?

[Section titled “stepIndex?”](#stepindex)

> `optional` **stepIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:312](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L312)

Step index that should emit the command.

***

### targetActorId?

[Section titled “targetActorId?”](#targetactorid)

> `optional` **targetActorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:348](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L348)

Expected target actor id.

***

### targetCanEnter?

[Section titled “targetCanEnter?”](#targetcanenter)

> `optional` **targetCanEnter?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:350](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L350)

Expected target enterability.

***

### targetIntent?

[Section titled “targetIntent?”](#targetintent)

> `optional` **targetIntent?**: [`GameboardInteractionIntent`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionintent/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:342](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L342)

Expected target intent.

***

### targetKind?

[Section titled “targetKind?”](#targetkind)

> `optional` **targetKind?**: [`GameboardInteractionTargetKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetkind/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:340](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L340)

Expected target kind.

***

### targetPlacementId?

[Section titled “targetPlacementId?”](#targetplacementid)

> `optional` **targetPlacementId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:346](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L346)

Expected target placement id.

***

### targetTileKey?

[Section titled “targetTileKey?”](#targettilekey)

> `optional` **targetTileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:344](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L344)

Expected target tile key.

***

### tileKey?

[Section titled “tileKey?”](#tilekey)

> `optional` **tileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:324](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L324)

Expected command tile key.

# GameboardScenarioSimulationCommandRecord

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:147](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L147)

Flattened command record with step provenance.

## Properties

[Section titled “Properties”](#properties)

### command

[Section titled “command”](#command)

> **command**: [`GameboardInteractionCommandRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandrecord/)

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:157](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L157)

Serializable command execution record.

***

### eventType

[Section titled “eventType”](#eventtype)

> **eventType**: `"movement-requested"` | `"command-handled"` | `"command-blocked"` | `"command-ignored"` | `"command-handler-required"` | `"patrol-move-requested"` | `"patrol-waiting"` | `"patrol-completed"` | `"patrol-blocked"` | `"movement-stepped"` | `"movement-completed"` | `"movement-blocked"` | `"quest-advanced"` | `"quest-completed"` | `"quest-blocked"`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:155](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L155)

Event type that carried the command.

***

### stepId?

[Section titled “stepId?”](#stepid)

> `optional` **stepId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:151](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L151)

Authored step id.

***

### stepIndex

[Section titled “stepIndex”](#stepindex)

> **stepIndex**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:149](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L149)

Step index that emitted the command.

***

### stepLabel?

[Section titled “stepLabel?”](#steplabel)

> `optional` **stepLabel?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:153](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L153)

Authored step label.

# GameboardScenarioSimulationCommandStep

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:94](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L94)

Runs an interaction command against a target.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"command"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:97](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L97)

Step discriminator.

***

### command?

[Section titled “command?”](#command)

> `optional` **command?**: `Omit`<[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/), `"systems"` | `"handlers"`>

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:103](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L103)

Command execution options excluding systems and handlers.

***

### handler?

[Section titled “handler?”](#handler)

> `optional` **handler?**: `"remove-target-actor"` | `"remove-target-placement"` | `"mark-target-interacted"` | `"default-rpg"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:105](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L105)

Single built-in command handler preset.

***

### handlerOptions?

[Section titled “handlerOptions?”](#handleroptions)

> `optional` **handlerOptions?**: [`CreateGameboardInteractionHandlerPresetOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardinteractionhandlerpresetoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:109](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L109)

Options for built-in command handler presets.

***

### handlers?

[Section titled “handlers?”](#handlers)

> `optional` **handlers?**: readonly (`"remove-target-actor"` | `"remove-target-placement"` | `"mark-target-interacted"` | `"default-rpg"`)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:107](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L107)

Built-in command handler presets.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L86)

Optional stable step id used by reports and expectations.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`id`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#id)

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L88)

Human-readable step label for reports.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`label`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#label)

***

### sourceActor?

[Section titled “sourceActor?”](#sourceactor)

> `optional` **sourceActor?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:101](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L101)

Source actor id used when the target must be planned.

***

### systems?

[Section titled “systems?”](#systems)

> `optional` **systems?**: `false` | [`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:111](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L111)

Systems to run after command dispatch, or false to skip.

***

### target

[Section titled “target”](#target)

> **target**: [`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:99](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L99)

Command target or already-planned command.

# GameboardScenarioSimulationExpectationFailure

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:574](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L574)

Failed expectation produced while building a simulation report.

## Properties

[Section titled “Properties”](#properties)

### actual?

[Section titled “actual?”](#actual)

> `optional` **actual?**: `unknown`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:582](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L582)

Actual value.

***

### expected?

[Section titled “expected?”](#expected)

> `optional` **expected?**: `unknown`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:580](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L580)

Expected value.

***

### message

[Section titled “message”](#message)

> **message**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:578](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L578)

Human-readable failure message.

***

### path

[Section titled “path”](#path)

> **path**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:576](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L576)

JSON-ish expectation path that failed.

# GameboardScenarioSimulationExpectations

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:282](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L282)

Expected records in a simulation report.

## Properties

[Section titled “Properties”](#properties)

### actors?

[Section titled “actors?”](#actors)

> `optional` **actors?**: readonly [`GameboardScenarioSimulationActorExpectation`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationactorexpectation/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:298](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L298)

Final actor-state expectations.

***

### actorTargets?

[Section titled “actorTargets?”](#actortargets)

> `optional` **actorTargets?**: readonly [`GameboardScenarioSimulationActorTargetsExpectation`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationactortargetsexpectation/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:290](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L290)

Actor-target report expectations.

***

### commands?

[Section titled “commands?”](#commands)

> `optional` **commands?**: readonly [`GameboardScenarioSimulationCommandExpectation`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationcommandexpectation/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:288](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L288)

Command expectations.

***

### eventTypes?

[Section titled “eventTypes?”](#eventtypes)

> `optional` **eventTypes?**: readonly (`"movement-requested"` | `"command-handled"` | `"command-blocked"` | `"command-ignored"` | `"command-handler-required"` | `"patrol-move-requested"` | `"patrol-waiting"` | `"patrol-completed"` | `"patrol-blocked"` | `"movement-stepped"` | `"movement-completed"` | `"movement-blocked"` | `"quest-advanced"` | `"quest-completed"` | `"quest-blocked"`)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:284](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L284)

Exact event type sequence expectation.

***

### movements?

[Section titled “movements?”](#movements)

> `optional` **movements?**: readonly [`GameboardScenarioSimulationMovementExpectation`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationmovementexpectation/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:294](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L294)

Movement event expectations.

***

### mutations?

[Section titled “mutations?”](#mutations)

> `optional` **mutations?**: readonly [`GameboardScenarioSimulationMutationExpectation`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationmutationexpectation/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:296](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L296)

Mutation expectations.

***

### patrols?

[Section titled “patrols?”](#patrols)

> `optional` **patrols?**: readonly [`GameboardScenarioSimulationPatrolExpectation`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationpatrolexpectation/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:292](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L292)

Patrol event expectations.

***

### placements?

[Section titled “placements?”](#placements)

> `optional` **placements?**: readonly [`GameboardScenarioSimulationPlacementExpectation`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationplacementexpectation/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:300](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L300)

Final placement-state expectations.

***

### quests?

[Section titled “quests?”](#quests)

> `optional` **quests?**: readonly [`GameboardScenarioSimulationQuestExpectation`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationquestexpectation/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:302](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L302)

Final quest-state expectations.

***

### requiredEventTypes?

[Section titled “requiredEventTypes?”](#requiredeventtypes)

> `optional` **requiredEventTypes?**: readonly (`"movement-requested"` | `"command-handled"` | `"command-blocked"` | `"command-ignored"` | `"command-handler-required"` | `"patrol-move-requested"` | `"patrol-waiting"` | `"patrol-completed"` | `"patrol-blocked"` | `"movement-stepped"` | `"movement-completed"` | `"movement-blocked"` | `"quest-advanced"` | `"quest-completed"` | `"quest-blocked"`)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:286](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L286)

Event types that must appear at least once.

# GameboardScenarioSimulationMovementExpectation

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:408](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L408)

Expected movement record in a simulation report.

## Properties

[Section titled “Properties”](#properties)

### actorId?

[Section titled “actorId?”](#actorid)

> `optional` **actorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:416](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L416)

Expected actor id.

***

### assetId?

[Section titled “assetId?”](#assetid)

> `optional` **assetId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:422](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L422)

Expected placement asset id.

***

### cost?

[Section titled “cost?”](#cost)

> `optional` **cost?**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:438](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L438)

Expected planned path cost.

***

### destinationKey?

[Section titled “destinationKey?”](#destinationkey)

> `optional` **destinationKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:430](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L430)

Expected movement destination key.

***

### eventType?

[Section titled “eventType?”](#eventtype)

> `optional` **eventType?**: `"movement-requested"` | `"movement-stepped"` | `"movement-completed"` | `"movement-blocked"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:414](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L414)

Expected movement event type.

***

### moved?

[Section titled “moved?”](#moved)

> `optional` **moved?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:426](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L426)

Expected moved flag.

***

### nextIndex?

[Section titled “nextIndex?”](#nextindex)

> `optional` **nextIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:436](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L436)

Expected next path index.

***

### pathIncludes?

[Section titled “pathIncludes?”](#pathincludes)

> `optional` **pathIncludes?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:434](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L434)

Path tile keys that must be included.

***

### pathKeys?

[Section titled “pathKeys?”](#pathkeys)

> `optional` **pathKeys?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:432](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L432)

Expected exact path tile keys.

***

### placementId?

[Section titled “placementId?”](#placementid)

> `optional` **placementId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:418](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L418)

Expected placement id.

***

### profileId?

[Section titled “profileId?”](#profileid)

> `optional` **profileId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:424](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L424)

Expected movement profile id.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:444](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L444)

Expected movement reason.

***

### spentCost?

[Section titled “spentCost?”](#spentcost)

> `optional` **spentCost?**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:440](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L440)

Expected spent path cost.

***

### status?

[Section titled “status?”](#status)

> `optional` **status?**: [`GameboardMovementStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementstatus/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:428](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L428)

Expected movement status.

***

### stepId?

[Section titled “stepId?”](#stepid)

> `optional` **stepId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:410](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L410)

Step id that should emit the movement record.

***

### stepIndex?

[Section titled “stepIndex?”](#stepindex)

> `optional` **stepIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:412](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L412)

Step index that should emit the movement record.

***

### tileKey?

[Section titled “tileKey?”](#tilekey)

> `optional` **tileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:420](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L420)

Expected current tile key.

***

### visited?

[Section titled “visited?”](#visited)

> `optional` **visited?**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:442](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L442)

Expected pathfinder visited count.

# GameboardScenarioSimulationMovementRecord

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:179](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L179)

Flattened movement event record with step provenance.

## Properties

[Section titled “Properties”](#properties)

### eventType

[Section titled “eventType”](#eventtype)

> **eventType**: `"movement-requested"` | `"movement-stepped"` | `"movement-completed"` | `"movement-blocked"`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:187](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L187)

Movement event type.

***

### movement

[Section titled “movement”](#movement)

> **movement**: [`GameboardMovementEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementeventrecord/)

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:189](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L189)

Serializable movement event record.

***

### stepId?

[Section titled “stepId?”](#stepid)

> `optional` **stepId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:183](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L183)

Authored step id.

***

### stepIndex

[Section titled “stepIndex”](#stepindex)

> **stepIndex**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:181](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L181)

Step index that emitted the movement event.

***

### stepLabel?

[Section titled “stepLabel?”](#steplabel)

> `optional` **stepLabel?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:185](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L185)

Authored step label.

# GameboardScenarioSimulationMutationExpectation

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:484](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L484)

Expected mutation record in a simulation report.

## Properties

[Section titled “Properties”](#properties)

### actorId?

[Section titled “actorId?”](#actorid)

> `optional` **actorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:488](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L488)

Expected actor id.

***

### placementId?

[Section titled “placementId?”](#placementid)

> `optional` **placementId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:490](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L490)

Expected placement id.

***

### removed?

[Section titled “removed?”](#removed)

> `optional` **removed?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:492](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L492)

Expected removed flag.

***

### spawned?

[Section titled “spawned?”](#spawned)

> `optional` **spawned?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:494](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L494)

Expected spawned flag.

***

### type?

[Section titled “type?”](#type)

> `optional` **type?**: `"actor-removed"` | `"placement-removed"` | `"actor-updated"` | `"placement-updated"` | `"actor-spawned"` | `"placement-spawned"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:486](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L486)

Expected mutation type.

***

### updated?

[Section titled “updated?”](#updated)

> `optional` **updated?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:496](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L496)

Expected updated flag.

# GameboardScenarioSimulationMutationRecord

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:756](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L756)

Serializable mutation record emitted by direct mutation simulation steps.

## Properties

[Section titled “Properties”](#properties)

### actorId?

[Section titled “actorId?”](#actorid)

> `optional` **actorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:766](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L766)

Actor id involved in the mutation.

***

### placementId?

[Section titled “placementId?”](#placementid)

> `optional` **placementId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:768](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L768)

Placement id involved in the mutation.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:776](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L776)

Optional failure or diagnostic reason.

***

### removed?

[Section titled “removed?”](#removed)

> `optional` **removed?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:770](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L770)

Whether an entity was removed.

***

### spawned?

[Section titled “spawned?”](#spawned)

> `optional` **spawned?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:772](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L772)

Whether an entity was spawned.

***

### type

[Section titled “type”](#type)

> **type**: `"actor-removed"` | `"placement-removed"` | `"actor-updated"` | `"placement-updated"` | `"actor-spawned"` | `"placement-spawned"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:758](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L758)

Mutation type.

***

### updated?

[Section titled “updated?”](#updated)

> `optional` **updated?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:774](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L774)

Whether an entity was updated.

# GameboardScenarioSimulationPatrolExpectation

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:450](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L450)

Expected patrol record in a simulation report.

## Properties

[Section titled “Properties”](#properties)

### actorId?

[Section titled “actorId?”](#actorid)

> `optional` **actorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:458](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L458)

Expected actor id.

***

### advanced?

[Section titled “advanced?”](#advanced)

> `optional` **advanced?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:476](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L476)

Expected waypoint-advanced flag.

***

### currentWaypointIndex?

[Section titled “currentWaypointIndex?”](#currentwaypointindex)

> `optional` **currentWaypointIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:468](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L468)

Expected current waypoint index.

***

### eventType?

[Section titled “eventType?”](#eventtype)

> `optional` **eventType?**: `"patrol-move-requested"` | `"patrol-waiting"` | `"patrol-completed"` | `"patrol-blocked"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:456](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L456)

Expected patrol event type.

***

### placementId?

[Section titled “placementId?”](#placementid)

> `optional` **placementId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:460](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L460)

Expected placement id.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:478](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L478)

Expected patrol reason.

***

### requested?

[Section titled “requested?”](#requested)

> `optional` **requested?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:474](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L474)

Expected movement-request flag.

***

### roundsCompleted?

[Section titled “roundsCompleted?”](#roundscompleted)

> `optional` **roundsCompleted?**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:472](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L472)

Expected completed route rounds.

***

### routeId?

[Section titled “routeId?”](#routeid)

> `optional` **routeId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:462](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L462)

Expected patrol route id.

***

### status?

[Section titled “status?”](#status)

> `optional` **status?**: [`GameboardPatrolStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardpatrolstatus/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:464](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L464)

Expected patrol status.

***

### stepId?

[Section titled “stepId?”](#stepid)

> `optional` **stepId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:452](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L452)

Step id that should emit the patrol record.

***

### stepIndex?

[Section titled “stepIndex?”](#stepindex)

> `optional` **stepIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:454](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L454)

Step index that should emit the patrol record.

***

### targetKey?

[Section titled “targetKey?”](#targetkey)

> `optional` **targetKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:466](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L466)

Expected target tile key.

***

### targetWaypointIndex?

[Section titled “targetWaypointIndex?”](#targetwaypointindex)

> `optional` **targetWaypointIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:470](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L470)

Expected target waypoint index.

# GameboardScenarioSimulationPatrolRecord

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:163](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L163)

Flattened patrol event record with step provenance.

## Properties

[Section titled “Properties”](#properties)

### eventType

[Section titled “eventType”](#eventtype)

> **eventType**: `"patrol-move-requested"` | `"patrol-waiting"` | `"patrol-completed"` | `"patrol-blocked"`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:171](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L171)

Patrol event type.

***

### patrol

[Section titled “patrol”](#patrol)

> **patrol**: [`GameboardPatrolEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroleventrecord/)

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:173](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L173)

Serializable patrol event record.

***

### stepId?

[Section titled “stepId?”](#stepid)

> `optional` **stepId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:167](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L167)

Authored step id.

***

### stepIndex

[Section titled “stepIndex”](#stepindex)

> **stepIndex**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:165](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L165)

Step index that emitted the patrol event.

***

### stepLabel?

[Section titled “stepLabel?”](#steplabel)

> `optional` **stepLabel?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:169](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L169)

Authored step label.

# GameboardScenarioSimulationPlacementExpectation

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:534](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L534)

Expected final placement state in a simulation report.

## Properties

[Section titled “Properties”](#properties)

### assetId?

[Section titled “assetId?”](#assetid)

> `optional` **assetId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:542](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L542)

Expected asset id.

***

### exists?

[Section titled “exists?”](#exists)

> `optional` **exists?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:538](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L538)

Whether the placement is expected to exist.

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:544](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L544)

Expected placement kind.

***

### layer?

[Section titled “layer?”](#layer)

> `optional` **layer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:546](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L546)

Expected placement layer.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>>

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:550](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L550)

Placement metadata entries that must match.

***

### placementId

[Section titled “placementId”](#placementid)

> **placementId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:536](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L536)

Placement id to inspect.

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:548](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L548)

Expected local-only asset flag.

***

### tileKey?

[Section titled “tileKey?”](#tilekey)

> `optional` **tileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:540](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L540)

Expected tile key.

# GameboardScenarioSimulationPlacementRecord

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:221](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L221)

Final placement record in a simulation report.

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:227](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L227)

Asset id.

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:229](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L229)

Placement kind.

***

### layer

[Section titled “layer”](#layer)

> **layer**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:231](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L231)

Placement layer.

***

### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Readonly`<`Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>>

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:235](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L235)

Serializable placement metadata.

***

### placementId

[Section titled “placementId”](#placementid)

> **placementId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:223](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L223)

Placement id.

***

### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:233](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L233)

Whether the placement depends on local EXTRA or external assets.

***

### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:225](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L225)

Origin tile key.

# GameboardScenarioSimulationQuestExpectation

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:556](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L556)

Expected final quest state in a simulation report.

## Properties

[Section titled “Properties”](#properties)

### activeObjectiveId?

[Section titled “activeObjectiveId?”](#activeobjectiveid)

> `optional` **activeObjectiveId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:562](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L562)

Expected active objective id.

***

### blockedObjectives?

[Section titled “blockedObjectives?”](#blockedobjectives)

> `optional` **blockedObjectives?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:566](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L566)

Objective ids expected to be blocked.

***

### completedObjectives?

[Section titled “completedObjectives?”](#completedobjectives)

> `optional` **completedObjectives?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:564](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L564)

Objective ids expected to be completed.

***

### pendingObjectives?

[Section titled “pendingObjectives?”](#pendingobjectives)

> `optional` **pendingObjectives?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:568](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L568)

Objective ids expected to be pending.

***

### questId

[Section titled “questId”](#questid)

> **questId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:558](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L558)

Quest id to inspect.

***

### status?

[Section titled “status?”](#status)

> `optional` **status?**: [`GameboardQuestStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardqueststatus/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:560](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L560)

Expected quest status.

# GameboardScenarioSimulationQuestRecord

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:241](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L241)

Final quest record in a simulation report.

## Properties

[Section titled “Properties”](#properties)

### activeObjectiveId?

[Section titled “activeObjectiveId?”](#activeobjectiveid)

> `optional` **activeObjectiveId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:251](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L251)

Active objective id.

***

### activeObjectiveIndex

[Section titled “activeObjectiveIndex”](#activeobjectiveindex)

> **activeObjectiveIndex**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:249](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L249)

Active objective index.

***

### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Readonly`<`Record`<`string`, [`GameboardQuestMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestmetadatavalue/)>>

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:257](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L257)

Serializable quest metadata.

***

### objectives

[Section titled “objectives”](#objectives)

> **objectives**: readonly [`GameboardQuestObjective`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestobjective/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:253](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L253)

Quest objectives.

***

### progress

[Section titled “progress”](#progress)

> **progress**: readonly [`GameboardQuestObjectiveProgress`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectiveprogress/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:255](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L255)

Objective progress snapshots.

***

### questId

[Section titled “questId”](#questid)

> **questId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:243](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L243)

Quest id.

***

### status

[Section titled “status”](#status)

> **status**: [`GameboardQuestStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardqueststatus/)

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:247](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L247)

Quest status.

***

### title

[Section titled “title”](#title)

> **title**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:245](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L245)

Quest title.

# GameboardScenarioSimulationRemoveActorStep

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:171](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L171)

Removes an actor-backed placement.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"remove-actor"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:174](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L174)

Step discriminator.

***

### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:176](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L176)

Actor id to remove.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L86)

Optional stable step id used by reports and expectations.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`id`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#id)

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L88)

Human-readable step label for reports.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`label`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#label)

***

### systems?

[Section titled “systems?”](#systems)

> `optional` **systems?**: `false` | [`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:178](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L178)

Systems to run after removal, or false to skip.

# GameboardScenarioSimulationRemovePlacementStep

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:184](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L184)

Removes a placement by id.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"remove-placement"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:187](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L187)

Step discriminator.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L86)

Optional stable step id used by reports and expectations.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`id`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#id)

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L88)

Human-readable step label for reports.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`label`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#label)

***

### placementId

[Section titled “placementId”](#placementid)

> **placementId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:189](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L189)

Placement id to remove.

***

### systems?

[Section titled “systems?”](#systems)

> `optional` **systems?**: `false` | [`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:191](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L191)

Systems to run after removal, or false to skip.

# GameboardScenarioSimulationReport

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:85](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L85)

Serializable report derived from a simulation result.

## Properties

[Section titled “Properties”](#properties)

### actors

[Section titled “actors”](#actors)

> **actors**: readonly [`GameboardScenarioSimulationActorRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationactorrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:113](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L113)

Final actor records.

***

### actorTargets

[Section titled “actorTargets”](#actortargets)

> **actorTargets**: readonly [`GameboardScenarioSimulationActorTargetsRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationactortargetsrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:99](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L99)

Flattened actor-target records.

***

### commands

[Section titled “commands”](#commands)

> **commands**: readonly [`GameboardScenarioSimulationCommandRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationcommandrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:97](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L97)

Flattened command records.

***

### eventRecords

[Section titled “eventRecords”](#eventrecords)

> **eventRecords**: readonly [`GameboardSystemEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardsystemeventrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:105](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L105)

Flattened system event records.

***

### expectationFailures

[Section titled “expectationFailures”](#expectationfailures)

> **expectationFailures**: readonly [`GameboardScenarioSimulationExpectationFailure`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationexpectationfailure/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:119](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L119)

Expectation failures.

***

### expectations?

[Section titled “expectations?”](#expectations)

> `optional` **expectations?**: [`GameboardScenarioSimulationExpectations`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationexpectations/)

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:117](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L117)

Expectations evaluated for the report.

***

### finalPlan

[Section titled “finalPlan”](#finalplan)

> **finalPlan**: [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:109](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L109)

Final projected plan.

***

### movements

[Section titled “movements”](#movements)

> **movements**: readonly [`GameboardScenarioSimulationMovementRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationmovementrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:103](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L103)

Flattened movement records.

***

### mutations

[Section titled “mutations”](#mutations)

> **mutations**: readonly [`GameboardScenarioSimulationMutationRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationmutationrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:107](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L107)

Direct mutation records.

***

### patrols

[Section titled “patrols”](#patrols)

> **patrols**: readonly [`GameboardScenarioSimulationPatrolRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationpatrolrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:101](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L101)

Flattened patrol records.

***

### placements

[Section titled “placements”](#placements)

> **placements**: readonly [`GameboardScenarioSimulationPlacementRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationplacementrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:111](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L111)

Final placement records.

***

### quests

[Section titled “quests”](#quests)

> **quests**: readonly [`GameboardScenarioSimulationQuestRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationquestrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:115](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L115)

Final quest records.

***

### scenarioId

[Section titled “scenarioId”](#scenarioid)

> **scenarioId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:89](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L89)

Scenario id.

***

### scenarioTitle?

[Section titled “scenarioTitle?”](#scenariotitle)

> `optional` **scenarioTitle?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:91](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L91)

Scenario title.

***

### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> **schemaVersion**: `"1.0.0"`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:87](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L87)

Simulation schema version.

***

### steps

[Section titled “steps”](#steps)

> **steps**: readonly [`GameboardScenarioSimulationStepReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepreport/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:95](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L95)

Per-step report records.

***

### success

[Section titled “success”](#success)

> **success**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:93](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L93)

Whether all expectations passed.

# GameboardScenarioSimulationResult

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:63](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L63)

In-memory result of running a scenario simulation.

## Properties

[Section titled “Properties”](#properties)

### actors

[Section titled “actors”](#actors)

> **actors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:77](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L77)

Final actor snapshots.

***

### eventRecords

[Section titled “eventRecords”](#eventrecords)

> **eventRecords**: readonly [`GameboardSystemEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardsystemeventrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:71](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L71)

All serializable event records emitted during the run.

***

### events

[Section titled “events”](#events)

> **events**: readonly [`GameboardSystemEvent`](/declarative-hex-worlds/reference/index/type-aliases/gameboardsystemevent/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:69](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L69)

All in-memory events emitted during the run.

***

### finalPlan

[Section titled “finalPlan”](#finalplan)

> **finalPlan**: [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:75](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L75)

Final projected plan.

***

### mutations

[Section titled “mutations”](#mutations)

> **mutations**: readonly [`GameboardScenarioSimulationMutationRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationmutationrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:73](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L73)

All direct mutation records emitted during the run.

***

### quests

[Section titled “quests”](#quests)

> **quests**: readonly [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:79](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L79)

Final quest snapshots.

***

### runtime

[Section titled “runtime”](#runtime)

> **runtime**: [`GameboardScenarioRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenarioruntime/)

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L65)

Runtime created from the scenario.

***

### steps

[Section titled “steps”](#steps)

> **steps**: readonly [`GameboardScenarioSimulationStepResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepresult/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L67)

Per-step execution results.

# GameboardScenarioSimulationRunSystemsStep

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:160](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L160)

Runs patrol, movement, and quest systems.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"run-systems"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:163](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L163)

Step discriminator.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L86)

Optional stable step id used by reports and expectations.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`id`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#id)

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L88)

Human-readable step label for reports.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`label`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#label)

***

### systems?

[Section titled “systems?”](#systems)

> `optional` **systems?**: [`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:165](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L165)

Systems to run.

# GameboardScenarioSimulationScript

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:255](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L255)

Serializable script for deterministic scenario simulation.

## Properties

[Section titled “Properties”](#properties)

### defaultCommandHandlerOptions?

[Section titled “defaultCommandHandlerOptions?”](#defaultcommandhandleroptions)

> `optional` **defaultCommandHandlerOptions?**: [`CreateGameboardInteractionHandlerPresetOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardinteractionhandlerpresetoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:267](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L267)

Default options for built-in command handler presets.

***

### defaultCommandHandlers?

[Section titled “defaultCommandHandlers?”](#defaultcommandhandlers)

> `optional` **defaultCommandHandlers?**: readonly (`"remove-target-actor"` | `"remove-target-placement"` | `"mark-target-interacted"` | `"default-rpg"`)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:265](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L265)

Default built-in command handler presets.

***

### defaultCommandSystems?

[Section titled “defaultCommandSystems?”](#defaultcommandsystems)

> `optional` **defaultCommandSystems?**: `false` | [`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:263](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L263)

Default systems after command dispatch, or false to skip.

***

### defaultRunSystems?

[Section titled “defaultRunSystems?”](#defaultrunsystems)

> `optional` **defaultRunSystems?**: [`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:269](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L269)

Default systems for run-systems steps.

***

### defaultSourceActor?

[Section titled “defaultSourceActor?”](#defaultsourceactor)

> `optional` **defaultSourceActor?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:261](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L261)

Default source actor id for command steps.

***

### expectations?

[Section titled “expectations?”](#expectations)

> `optional` **expectations?**: [`GameboardScenarioSimulationExpectations`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationexpectations/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:271](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L271)

Optional expectations evaluated against the report.

***

### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> **schemaVersion**: `"1.0.0"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:257](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L257)

Simulation schema version.

***

### steps

[Section titled “steps”](#steps)

> **steps**: readonly [`GameboardScenarioSimulationStep`](/declarative-hex-worlds/reference/index/type-aliases/gameboardscenariosimulationstep/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:259](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L259)

Steps to execute in order.

# GameboardScenarioSimulationScriptValidationConfig

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:705](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L705)

Validation context for an authored simulation script.

## Properties

[Section titled “Properties”](#properties)

### plan?

[Section titled “plan?”](#plan)

> `optional` **plan?**: [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:709](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L709)

Precompiled plan used when a scenario is not available.

***

### scenario?

[Section titled “scenario?”](#scenario)

> `optional` **scenario?**: [`GameboardScenario`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenario/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:707](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L707)

Scenario used to resolve actors, quests, and plan references.

# GameboardScenarioSimulationScriptValidationResult

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:715](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L715)

Result of validating a simulation script.

## Properties

[Section titled “Properties”](#properties)

### plan?

[Section titled “plan?”](#plan)

> `optional` **plan?**: [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:719](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L719)

Plan compiled from validation context, when available.

***

### script

[Section titled “script”](#script)

> **script**: [`GameboardScenarioSimulationScript`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationscript/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:717](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L717)

Script that was validated.

***

### violations

[Section titled “violations”](#violations)

> **violations**: readonly [`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:721](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L721)

Validation violations.

# GameboardScenarioSimulationSpawnActorStep

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:197](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L197)

Spawns a scenario actor during a simulation.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"spawn-actor"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:200](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L200)

Step discriminator.

***

### actor

[Section titled “actor”](#actor)

> **actor**: [`GameboardScenarioActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenarioactor/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:202](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L202)

Actor declaration to spawn.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L86)

Optional stable step id used by reports and expectations.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`id`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#id)

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L88)

Human-readable step label for reports.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`label`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#label)

***

### systems?

[Section titled “systems?”](#systems)

> `optional` **systems?**: `false` | [`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:204](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L204)

Systems to run after spawn, or false to skip.

# GameboardScenarioSimulationSpawnPlacementStep

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:210](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L210)

Spawns a raw placement during a simulation.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"spawn-placement"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:213](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L213)

Step discriminator.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L86)

Optional stable step id used by reports and expectations.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`id`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#id)

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L88)

Human-readable step label for reports.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`label`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#label)

***

### placement

[Section titled “placement”](#placement)

> **placement**: [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:215](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L215)

Placement options to spawn.

***

### systems?

[Section titled “systems?”](#systems)

> `optional` **systems?**: `false` | [`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:217](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L217)

Systems to run after spawn, or false to skip.

# GameboardScenarioSimulationStepBase

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:84](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L84)

Common authored fields shared by all simulation steps.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`GameboardScenarioSimulationCommandStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationcommandstep/)
* [`GameboardScenarioSimulationActorTargetCommandStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationactortargetcommandstep/)
* [`GameboardScenarioSimulationActorTargetsStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationactortargetsstep/)
* [`GameboardScenarioSimulationRunSystemsStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationrunsystemsstep/)
* [`GameboardScenarioSimulationRemoveActorStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationremoveactorstep/)
* [`GameboardScenarioSimulationRemovePlacementStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationremoveplacementstep/)
* [`GameboardScenarioSimulationSpawnActorStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationspawnactorstep/)
* [`GameboardScenarioSimulationSpawnPlacementStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationspawnplacementstep/)
* [`GameboardScenarioSimulationUpdateActorStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationupdateactorstep/)
* [`GameboardScenarioSimulationUpdatePlacementStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationupdateplacementstep/)

## Properties

[Section titled “Properties”](#properties)

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L86)

Optional stable step id used by reports and expectations.

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L88)

Human-readable step label for reports.

# GameboardScenarioSimulationStepReport

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:125](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L125)

Serializable report for one simulation step.

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"command"` | `"actor-target-command"` | `"inspect-actor-targets"` | `"run-systems"` | `"remove-actor"` | `"remove-placement"` | `"spawn-actor"` | `"spawn-placement"` | `"update-actor"` | `"update-placement"`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:133](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L133)

Step action discriminator.

***

### actorTargets?

[Section titled “actorTargets?”](#actortargets)

> `optional` **actorTargets?**: [`GameboardScenarioSimulationActorTargetsRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationactortargetsrecord/)

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:137](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L137)

Actor-target record emitted by the step.

***

### command?

[Section titled “command?”](#command)

> `optional` **command?**: [`GameboardInteractionCommandRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandrecord/)

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:135](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L135)

Command record emitted by the step.

***

### eventRecords

[Section titled “eventRecords”](#eventrecords)

> **eventRecords**: readonly [`GameboardSystemEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardsystemeventrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:139](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L139)

System event records emitted by the step.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:129](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L129)

Authored step id.

***

### index

[Section titled “index”](#index)

> **index**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:127](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L127)

Step index.

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:131](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L131)

Authored step label.

***

### mutations

[Section titled “mutations”](#mutations)

> **mutations**: readonly [`GameboardScenarioSimulationMutationRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationmutationrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/report.ts:141](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/report.ts#L141)

Direct mutation records emitted by the step.

# GameboardScenarioSimulationStepResult

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:730](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L730)

Runtime result for one executed simulation step.

The full shape is defined here (alongside the step types) so authored scripts and runtime results share a single source of truth.

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"command"` | `"actor-target-command"` | `"inspect-actor-targets"` | `"run-systems"` | `"remove-actor"` | `"remove-placement"` | `"spawn-actor"` | `"spawn-placement"` | `"update-actor"` | `"update-placement"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:738](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L738)

Step action discriminator.

***

### actorTargets?

[Section titled “actorTargets?”](#actortargets)

> `optional` **actorTargets?**: [`GameboardScenarioSimulationActorTargetsRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationactortargetsrecord/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:742](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L742)

Actor-target report for target-inspection steps.

***

### dispatch?

[Section titled “dispatch?”](#dispatch)

> `optional` **dispatch?**: [`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:740](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L740)

Command dispatch result for command steps.

***

### eventRecords

[Section titled “eventRecords”](#eventrecords)

> **eventRecords**: readonly [`GameboardSystemEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardsystemeventrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:748](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L748)

Serializable event records emitted by the step.

***

### events

[Section titled “events”](#events)

> **events**: readonly [`GameboardSystemEvent`](/declarative-hex-worlds/reference/index/type-aliases/gameboardsystemevent/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:746](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L746)

In-memory events emitted by the step.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:734](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L734)

Authored step id.

***

### index

[Section titled “index”](#index)

> **index**: `number`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:732](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L732)

Step index.

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:736](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L736)

Authored step label.

***

### mutations

[Section titled “mutations”](#mutations)

> **mutations**: readonly [`GameboardScenarioSimulationMutationRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationmutationrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:750](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L750)

Mutations directly performed by this step.

***

### systems?

[Section titled “systems?”](#systems)

> `optional` **systems?**: [`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:744](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L744)

System tick result for run-systems or post-command systems.

# GameboardScenarioSimulationUpdateActorStep

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:223](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L223)

Updates an actor and optionally its placement.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"update-actor"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:226](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L226)

Step discriminator.

***

### actor

[Section titled “actor”](#actor)

> **actor**: [`UpdateGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardactoroptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:230](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L230)

Actor update options.

***

### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:228](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L228)

Actor id to update.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L86)

Optional stable step id used by reports and expectations.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`id`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#id)

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L88)

Human-readable step label for reports.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`label`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#label)

***

### placement?

[Section titled “placement?”](#placement)

> `optional` **placement?**: [`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:232](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L232)

Optional placement update options for the actor placement.

***

### systems?

[Section titled “systems?”](#systems)

> `optional` **systems?**: `false` | [`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:234](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L234)

Systems to run after update, or false to skip.

# GameboardScenarioSimulationUpdatePlacementStep

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:240](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L240)

Updates a placement by id.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"update-placement"`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:243](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L243)

Step discriminator.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L86)

Optional stable step id used by reports and expectations.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`id`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#id)

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L88)

Human-readable step label for reports.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardScenarioSimulationStepBase`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/).[`label`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationstepbase/#label)

***

### placement

[Section titled “placement”](#placement)

> **placement**: [`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:247](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L247)

Placement update options.

***

### placementId

[Section titled “placementId”](#placementid)

> **placementId**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:245](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L245)

Placement id to update.

***

### systems?

[Section titled “systems?”](#systems)

> `optional` **systems?**: `false` | [`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:249](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L249)

Systems to run after update, or false to skip.

# GameboardScenarioSummary

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:246](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L246)

Aggregate inspection result for a playable scenario.

This is designed for editor panels, CI diagnostics, screenshot manifests, external ECS bridges, and agent audits that need to prove a board is not only visually complete, but also has the expected actors, spawns, routes, and quest objectives before a renderer loads it.

## Properties

[Section titled “Properties”](#properties)

### actorAssetCounts

[Section titled “actorAssetCounts”](#actorassetcounts)

> **actorAssetCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:282](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L282)

Actor count by asset id.

***

### actorCount

[Section titled “actorCount”](#actorcount)

> **actorCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:258](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L258)

Number of authored actors.

***

### actorExtraAssetIds

[Section titled “actorExtraAssetIds”](#actorextraassetids)

> **actorExtraAssetIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:284](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L284)

Unique actor asset ids marked as requiring local-only assets.

***

### actorKindCounts

[Section titled “actorKindCounts”](#actorkindcounts)

> **actorKindCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:272](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L272)

Actor count by gameplay kind.

***

### actors

[Section titled “actors”](#actors)

> **actors**: readonly [`GameboardScenarioActorSummary`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenarioactorsummary/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:288](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L288)

Per-actor rows useful for editor sidebars and E2E fixtures.

***

### actorSpawnGroupCounts

[Section titled “actorSpawnGroupCounts”](#actorspawngroupcounts)

> **actorSpawnGroupCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:276](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L276)

Actor count by referenced spawn group.

***

### actorTagCounts

[Section titled “actorTagCounts”](#actortagcounts)

> **actorTagCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:280](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L280)

Actor tag counts.

***

### actorTeamCounts

[Section titled “actorTeamCounts”](#actorteamcounts)

> **actorTeamCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:274](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L274)

Actor count by team or faction.

***

### actorTileCounts

[Section titled “actorTileCounts”](#actortilecounts)

> **actorTileCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:278](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L278)

Actor count by resolved or explicit spawn tile key.

***

### blockingActorCount

[Section titled “blockingActorCount”](#blockingactorcount)

> **blockingActorCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:270](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L270)

Number of movement-blocking actors.

***

### board?

[Section titled “board?”](#board)

> `optional` **board?**: [`GameboardPlanSummary`](/declarative-hex-worlds/reference/index/interfaces/gameboardplansummary/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:254](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L254)

Summary of the compiled board, when the board recipe compiles.

***

### hostileActorCount

[Section titled “hostileActorCount”](#hostileactorcount)

> **hostileActorCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:266](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L266)

Number of generally hostile actors.

***

### interactiveActorCount

[Section titled “interactiveActorCount”](#interactiveactorcount)

> **interactiveActorCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:268](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L268)

Number of interaction-target actors.

***

### movementAgentCount

[Section titled “movementAgentCount”](#movementagentcount)

> **movementAgentCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:262](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L262)

Number of actors with movement agents.

***

### objectiveActorCounts

[Section titled “objectiveActorCounts”](#objectiveactorcounts)

> **objectiveActorCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:296](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L296)

Objective references by source actor id.

***

### objectiveCount

[Section titled “objectiveCount”](#objectivecount)

> **objectiveCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:292](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L292)

Number of authored quest objectives.

***

### objectiveKindCounts

[Section titled “objectiveKindCounts”](#objectivekindcounts)

> **objectiveKindCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:294](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L294)

Objective count by objective kind.

***

### objectiveTargetActorCounts

[Section titled “objectiveTargetActorCounts”](#objectivetargetactorcounts)

> **objectiveTargetActorCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:298](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L298)

Objective references by target actor id.

***

### patrolAgentCount

[Section titled “patrolAgentCount”](#patrolagentcount)

> **patrolAgentCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:264](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L264)

Number of actors with patrol agents.

***

### patrolErrorCount

[Section titled “patrolErrorCount”](#patrolerrorcount)

> **patrolErrorCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:330](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L330)

Patrol route error count.

***

### patrolRouteCount

[Section titled “patrolRouteCount”](#patrolroutecount)

> **patrolRouteCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:318](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L318)

Number of planned patrol routes.

***

### patrolRouteFoundCount

[Section titled “patrolRouteFoundCount”](#patrolroutefoundcount)

> **patrolRouteFoundCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:320](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L320)

Number of planned patrol routes that satisfy required segments.

***

### patrolRouteMissingCount

[Section titled “patrolRouteMissingCount”](#patrolroutemissingcount)

> **patrolRouteMissingCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:322](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L322)

Number of planned patrol routes with missing required segments.

***

### patrolRouteWaypointCounts

[Section titled “patrolRouteWaypointCounts”](#patrolroutewaypointcounts)

> **patrolRouteWaypointCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:326](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L326)

Waypoint count by patrol route id.

***

### patrolWarningCount

[Section titled “patrolWarningCount”](#patrolwarningcount)

> **patrolWarningCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:328](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L328)

Patrol route warning count.

***

### patrolWaypointCount

[Section titled “patrolWaypointCount”](#patrolwaypointcount)

> **patrolWaypointCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:324](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L324)

Number of selected patrol waypoints.

***

### questCount

[Section titled “questCount”](#questcount)

> **questCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:290](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L290)

Number of authored quests.

***

### resolvedActorCount

[Section titled “resolvedActorCount”](#resolvedactorcount)

> **resolvedActorCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:260](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L260)

Number of actors whose spawn tile could be resolved.

***

### scenarioId

[Section titled “scenarioId”](#scenarioid)

> **scenarioId**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:250](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L250)

Stable scenario id.

***

### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> **schemaVersion**: `"1.0.0"`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:248](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L248)

Scenario schema version.

***

### spawnErrorCount

[Section titled “spawnErrorCount”](#spawnerrorcount)

> **spawnErrorCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:316](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L316)

Spawn planning error count.

***

### spawnGroupCandidateCounts

[Section titled “spawnGroupCandidateCounts”](#spawngroupcandidatecounts)

> **spawnGroupCandidateCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:306](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L306)

Spawn candidate count by group id after filtering.

***

### spawnGroupCount

[Section titled “spawnGroupCount”](#spawngroupcount)

> **spawnGroupCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:300](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L300)

Number of planned spawn groups.

***

### spawnGroupLocationCounts

[Section titled “spawnGroupLocationCounts”](#spawngrouplocationcounts)

> **spawnGroupLocationCounts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:304](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L304)

Spawn location count by group id.

***

### spawnLocationCount

[Section titled “spawnLocationCount”](#spawnlocationcount)

> **spawnLocationCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:302](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L302)

Number of selected spawn locations.

***

### spawnRouteCheckCount

[Section titled “spawnRouteCheckCount”](#spawnroutecheckcount)

> **spawnRouteCheckCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:308](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L308)

Number of spawn route checks.

***

### spawnRouteFoundCount

[Section titled “spawnRouteFoundCount”](#spawnroutefoundcount)

> **spawnRouteFoundCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:310](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L310)

Number of spawn route checks that found a path.

***

### spawnRouteMissingCount

[Section titled “spawnRouteMissingCount”](#spawnroutemissingcount)

> **spawnRouteMissingCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:312](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L312)

Number of spawn route checks that could not find a path.

***

### spawnWarningCount

[Section titled “spawnWarningCount”](#spawnwarningcount)

> **spawnWarningCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:314](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L314)

Spawn planning warning count.

***

### title?

[Section titled “title?”](#title)

> `optional` **title?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:252](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L252)

Optional display title.

***

### topActorAssets

[Section titled “topActorAssets”](#topactorassets)

> **topActorAssets**: readonly [`GameboardScenarioAssetSummary`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenarioassetsummary/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:286](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L286)

Highest-frequency actor asset summaries, sorted by count then asset id.

***

### validation

[Section titled “validation”](#validation)

> **validation**: [`GameboardScenarioSummaryValidation`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosummaryvalidation/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:256](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L256)

Validation counts and diagnostics.

# GameboardScenarioSummaryValidation

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:229](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L229)

Validation counts and violations included in scenario summaries.

## Properties

[Section titled “Properties”](#properties)

### errorCount

[Section titled “errorCount”](#errorcount)

> **errorCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:231](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L231)

Number of error-level violations.

***

### violations

[Section titled “violations”](#violations)

> **violations**: readonly [`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:235](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L235)

Scenario, spawn, route, actor, quest, and optional plan violations.

***

### warningCount

[Section titled “warningCount”](#warningcount)

> **warningCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:233](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L233)

Number of warning-level violations.

# GameboardScenarioValidationConfig

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:156](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L156)

Validation controls for scenario inspection.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`SummarizeGameboardScenarioOptions`](/declarative-hex-worlds/reference/index/interfaces/summarizegameboardscenariooptions/)

## Properties

[Section titled “Properties”](#properties)

### plan?

[Section titled “plan?”](#plan)

> `optional` **plan?**: [`GameboardPlanValidationConfig`](/declarative-hex-worlds/reference/rules/validation/interfaces/gameboardplanvalidationconfig/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:158](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L158)

Validation config passed to compiled plan validation.

***

### validatePlan?

[Section titled “validatePlan?”](#validateplan)

> `optional` **validatePlan?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:160](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L160)

Whether to validate the compiled plan in addition to scenario references.

# GameboardScenarioValidationResult

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:164](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L164)

Result from validating a scenario and its compiled board.

## Properties

[Section titled “Properties”](#properties)

### patrolRoutes?

[Section titled “patrolRoutes?”](#patrolroutes)

> `optional` **patrolRoutes?**: `GameboardPatrolRouteSet`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:172](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L172)

Patrol route plan when scenario patrol routes are configured.

***

### plan?

[Section titled “plan?”](#plan)

> `optional` **plan?**: [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:168](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L168)

Compiled plan when the board recipe succeeds.

***

### scenario

[Section titled “scenario”](#scenario)

> **scenario**: [`GameboardScenario`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenario/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:166](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L166)

Scenario that was inspected.

***

### spawnGroups?

[Section titled “spawnGroups?”](#spawngroups)

> `optional` **spawnGroups?**: `GameboardSpawnGroupPlan`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:170](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L170)

Spawn group plan when scenario spawn groups are configured.

***

### violations

[Section titled “violations”](#violations)

> **violations**: readonly [`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:174](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L174)

Scenario, spawn, route, actor, quest, and optional plan violations.

# GameboardSimulationInteropOptions

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:472](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L472)

Options for simulation interop snapshots.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/)

## Properties

[Section titled “Properties”](#properties)

### includeActors?

[Section titled “includeActors?”](#includeactors)

> `optional` **includeActors?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:474](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L474)

Include final actor entities and relations.

***

### includePlacements?

[Section titled “includePlacements?”](#includeplacements)

> `optional` **includePlacements?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:450](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L450)

Include placement entities and relations. Defaults to true.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/).[`includePlacements`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/#includeplacements)

***

### includeQuests?

[Section titled “includeQuests?”](#includequests)

> `optional` **includeQuests?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:476](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L476)

Include final quest entities and relations.

***

### includeTimeline?

[Section titled “includeTimeline?”](#includetimeline)

> `optional` **includeTimeline?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:478](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L478)

Include simulation timeline entities and relations.

***

### spawnLocations?

[Section titled “spawnLocations?”](#spawnlocations)

> `optional` **spawnLocations?**: `Omit`<[`SpawnLocationOptions`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocationoptions/), `"shape"`>

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:452](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L452)

Optional spawn-location generation options.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardInteropOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/).[`spawnLocations`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteropoptions/#spawnlocations)

# GameboardSimulationRelationRecord

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:352](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L352)

Relation payload for simulation timeline entities.

## Properties

[Section titled “Properties”](#properties)

### actorId?

[Section titled “actorId?”](#actorid)

> `optional` **actorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:364](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L364)

Related actor id.

***

### commandKind?

[Section titled “commandKind?”](#commandkind)

> `optional` **commandKind?**: [`GameboardInteractionCommandKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandkind/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:368](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L368)

Command kind, when related to a command.

***

### commandStatus?

[Section titled “commandStatus?”](#commandstatus)

> `optional` **commandStatus?**: [`GameboardInteractionExecutionStatus`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionexecutionstatus/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:370](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L370)

Command status, when related to a command.

***

### effectType?

[Section titled “effectType?”](#effecttype)

> `optional` **effectType?**: `"actor-removed"` | `"placement-removed"` | `"actor-updated"` | `"placement-updated"`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:392](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L392)

Individual command effect type.

***

### effectTypes?

[Section titled “effectTypes?”](#effecttypes)

> `optional` **effectTypes?**: readonly (`"actor-removed"` | `"placement-removed"` | `"actor-updated"` | `"placement-updated"`)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:376](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L376)

Command effect types.

***

### handlerId?

[Section titled “handlerId?”](#handlerid)

> `optional` **handlerId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:372](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L372)

Handler id, when a command handler ran.

***

### handlerStatus?

[Section titled “handlerStatus?”](#handlerstatus)

> `optional` **handlerStatus?**: [`GameboardInteractionHandlerStatus`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandlerstatus/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:374](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L374)

Handler status, when a command handler ran.

***

### mutationType?

[Section titled “mutationType?”](#mutationtype)

> `optional` **mutationType?**: `"actor-removed"` | `"placement-removed"` | `"actor-updated"` | `"placement-updated"` | `"actor-spawned"` | `"placement-spawned"`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:378](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L378)

Mutation type, when related to a mutation.

***

### placementId?

[Section titled “placementId?”](#placementid)

> `optional` **placementId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:366](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L366)

Related placement id.

***

### recordId?

[Section titled “recordId?”](#recordid)

> `optional` **recordId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:362](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L362)

Timeline record id.

***

### role

[Section titled “role”](#role)

> **role**: [`GameboardSimulationRelationRole`](/declarative-hex-worlds/reference/index/type-aliases/gameboardsimulationrelationrole/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:356](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L356)

Simulation relation role.

***

### scenarioId

[Section titled “scenarioId”](#scenarioid)

> **scenarioId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:354](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L354)

Scenario id that produced the simulation.

***

### stepId?

[Section titled “stepId?”](#stepid)

> `optional` **stepId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:360](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L360)

Simulation step entity id.

***

### stepIndex?

[Section titled “stepIndex?”](#stepindex)

> `optional` **stepIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:358](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L358)

Simulation step index.

***

### targetApproach?

[Section titled “targetApproach?”](#targetapproach)

> `optional` **targetApproach?**: [`GameboardActorTargetApproach`](/declarative-hex-worlds/reference/index/type-aliases/gameboardactortargetapproach/) | `"self"` | `"none"`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:382](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L382)

Approach mode for an actor target.

***

### targetApproachTileKey?

[Section titled “targetApproachTileKey?”](#targetapproachtilekey)

> `optional` **targetApproachTileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:384](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L384)

Approach tile key for an actor target.

***

### targetCommandCanExecute?

[Section titled “targetCommandCanExecute?”](#targetcommandcanexecute)

> `optional` **targetCommandCanExecute?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:390](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L390)

Whether the target command can execute.

***

### targetCommandKind?

[Section titled “targetCommandKind?”](#targetcommandkind)

> `optional` **targetCommandKind?**: [`GameboardInteractionCommandKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandkind/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:388](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L388)

Command kind planned for an actor target.

***

### targetPathCost?

[Section titled “targetPathCost?”](#targetpathcost)

> `optional` **targetPathCost?**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:386](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L386)

Path cost for an actor target.

***

### targetReachable?

[Section titled “targetReachable?”](#targetreachable)

> `optional` **targetReachable?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:380](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L380)

Whether an actor target was reachable.

# GameboardSnapshot

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:272](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L272)

Serializable snapshot of board, tile, and placement state.

## Properties

[Section titled “Properties”](#properties)

### board

[Section titled “board”](#board)

> **board**: { `placementCount`: `number`; `schemaVersion`: `string`; `seed`: `string`; `shape`: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/); `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileCount`: `number`; } | `undefined`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:274](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L274)

Board metadata, or `undefined` when no plan is loaded.

#### Union Members

[Section titled “Union Members”](#union-members)

##### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `placementCount`: `number`; `schemaVersion`: `string`; `seed`: `string`; `shape`: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/); `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileCount`: `number`; }

##### placementCount

[Section titled “placementCount”](#placementcount)

> **placementCount**: `number` = `0`

Number of placement entities loaded into the world.

##### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> **schemaVersion**: `string` = `GAMEBOARD_SCHEMA_VERSION`

Manifest/schema version used to generate the loaded board.

##### seed

[Section titled “seed”](#seed)

> **seed**: `string` = `''`

Seed used by deterministic layout or simulation helpers.

##### shape

[Section titled “shape”](#shape)

> **shape**: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

Board shape descriptor, such as rectangle or hexagon.

##### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Active KayKit texture set for generated terrain and placements.

##### tileCount

[Section titled “tileCount”](#tilecount)

> **tileCount**: `number` = `0`

Number of tile entities loaded into the world.

***

`undefined`

***

### placements

[Section titled “placements”](#placements)

> **placements**: readonly `object`\[]

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:278](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L278)

Placement states sorted by order and id.

***

### tiles

[Section titled “tiles”](#tiles)

> **tiles**: readonly `object`\[]

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:276](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L276)

Tile states sorted by axial tile key.

# GameboardSpawnGroupLocationRecord

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:172](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L172)

Relation payload connecting a spawn group to a selected location.

## Properties

[Section titled “Properties”](#properties)

### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:180](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L180)

Spawn tile coordinates.

***

### groupId

[Section titled “groupId”](#groupid)

> **groupId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:174](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L174)

Spawn group id.

***

### index

[Section titled “index”](#index)

> **index**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:182](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L182)

Location index inside the group.

***

### spawnId

[Section titled “spawnId”](#spawnid)

> **spawnId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:176](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L176)

Spawn location id.

***

### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:178](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L178)

Spawn tile key.

# GameboardSpawnGroupRecord

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:152](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L152)

Interop record for one spawn group.

## Properties

[Section titled “Properties”](#properties)

### candidateCount

[Section titled “candidateCount”](#candidatecount)

> **candidateCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:160](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L160)

Number of candidate locations.

***

### errors

[Section titled “errors”](#errors)

> **errors**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:166](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L166)

Fatal group diagnostics.

***

### groupId

[Section titled “groupId”](#groupid)

> **groupId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:154](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L154)

Spawn group id.

***

### rejectedByGroupDistanceCount

[Section titled “rejectedByGroupDistanceCount”](#rejectedbygroupdistancecount)

> **rejectedByGroupDistanceCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:162](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L162)

Number of candidates rejected by group-distance filtering.

***

### requestedCount

[Section titled “requestedCount”](#requestedcount)

> **requestedCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:156](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L156)

Number of requested locations.

***

### selectedCount

[Section titled “selectedCount”](#selectedcount)

> **selectedCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:158](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L158)

Number of selected locations.

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:164](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L164)

Non-fatal group diagnostics.

# GameboardSpawnGroupRouteRecord

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:188](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L188)

Interop route-check record between spawn groups.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardSpawnGroupRoute`](/declarative-hex-worlds/reference/gameboard/navigation/type-aliases/gameboardspawngrouproute/)

## Properties

[Section titled “Properties”](#properties)

### cost

[Section titled “cost”](#cost)

> **cost**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts:82](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts#L82)

Route cost.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

`GameboardSpawnGroupRoute.cost`

***

### found

[Section titled “found”](#found)

> **found**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts:74](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts#L74)

Whether a route was found.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

`GameboardSpawnGroupRoute.found`

***

### fromGroupId

[Section titled “fromGroupId”](#fromgroupid)

> **fromGroupId**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts:70](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts#L70)

Source group id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

`GameboardSpawnGroupRoute.fromGroupId`

***

### fromKey?

[Section titled “fromKey?”](#fromkey)

> `optional` **fromKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts:76](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts#L76)

Source location tile key.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

`GameboardSpawnGroupRoute.fromKey`

***

### pathKeys

[Section titled “pathKeys”](#pathkeys)

> **pathKeys**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts:80](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts#L80)

Path tile keys for the best route.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

`GameboardSpawnGroupRoute.pathKeys`

***

### toGroupId

[Section titled “toGroupId”](#togroupid)

> **toGroupId**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts:72](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts#L72)

Target group id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

`GameboardSpawnGroupRoute.toGroupId`

***

### toKey?

[Section titled “toKey?”](#tokey)

> `optional` **toKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts:78](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts#L78)

Target location tile key.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

`GameboardSpawnGroupRoute.toKey`

***

### visited

[Section titled “visited”](#visited)

> **visited**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts:84](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/spawn-groups.ts#L84)

Number of nodes visited by the pathfinder.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

`GameboardSpawnGroupRoute.visited`

# GameboardSpawnTileRecord

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:140](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L140)

Relation payload connecting a spawn location to a tile.

## Properties

[Section titled “Properties”](#properties)

### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:146](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L146)

Spawn tile coordinates.

***

### spawnId

[Section titled “spawnId”](#spawnid)

> **spawnId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:142](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L142)

Spawn location id.

***

### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:144](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L144)

Spawn tile key.

# GameboardSystemEventRecord

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:213](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L213)

Serializable event record for tests, logs, interop snapshots, and simulations.

## Properties

[Section titled “Properties”](#properties)

### beforeQuest?

[Section titled “beforeQuest?”](#beforequest)

> `optional` **beforeQuest?**: [`GameboardQuestEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardquesteventrecord/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:227](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L227)

Quest record before quest-related events.

***

### command?

[Section titled “command?”](#command)

> `optional` **command?**: [`GameboardInteractionCommandRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandrecord/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:219](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L219)

Command record for command-related events.

***

### movement?

[Section titled “movement?”](#movement)

> `optional` **movement?**: [`GameboardMovementEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementeventrecord/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:223](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L223)

Movement record for movement-related events.

***

### patrol?

[Section titled “patrol?”](#patrol)

> `optional` **patrol?**: [`GameboardPatrolEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroleventrecord/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:221](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L221)

Patrol record for patrol-related events.

***

### quest?

[Section titled “quest?”](#quest)

> `optional` **quest?**: [`GameboardQuestEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardquesteventrecord/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:225](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L225)

Quest record after quest-related events.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:217](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L217)

Optional failure or blocked reason.

***

### type

[Section titled “type”](#type)

> **type**: `"movement-requested"` | `"command-handled"` | `"command-blocked"` | `"command-ignored"` | `"command-handler-required"` | `"patrol-move-requested"` | `"patrol-waiting"` | `"patrol-completed"` | `"patrol-blocked"` | `"movement-stepped"` | `"movement-completed"` | `"movement-blocked"` | `"quest-advanced"` | `"quest-completed"` | `"quest-blocked"`

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:215](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L215)

Event discriminator.

# GameboardTileInspection

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:254](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L254)

Actor-aware tile inspection result for UI, AI, quests, and tests.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`GameboardNeighborhoodTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodtileinspection/)

## Properties

[Section titled “Properties”](#properties)

### actors

[Section titled “actors”](#actors)

> **actors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:274](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L274)

Actor placements on the tile.

***

### blockingPlacements

[Section titled “blockingPlacements”](#blockingplacements)

> **blockingPlacements**: readonly `object`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:282](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L282)

Placements that block movement onto the tile.

***

### canEnter

[Section titled “canEnter”](#canenter)

> **canEnter**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:286](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L286)

Whether the tile exists and can be entered.

***

### collision

[Section titled “collision”](#collision)

> **collision**: [`GameboardActorCollisionReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionreport/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:284](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L284)

Full collision report for the tile.

***

### coordinates?

[Section titled “coordinates?”](#coordinates)

> `optional` **coordinates?**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:262](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L262)

Axial coordinates, when the tile exists.

***

### elevation?

[Section titled “elevation?”](#elevation)

> `optional` **elevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:266](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L266)

Tile elevation, when the tile exists.

***

### exists

[Section titled “exists”](#exists)

> **exists**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:256](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L256)

Whether the tile exists in the board.

***

### hasActors

[Section titled “hasActors”](#hasactors)

> **hasActors**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:290](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L290)

Whether any actors occupy the tile.

***

### hasHostiles

[Section titled “hasHostiles”](#hashostiles)

> **hasHostiles**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:292](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L292)

Whether any hostile actors occupy the tile.

***

### hasInteractive

[Section titled “hasInteractive”](#hasinteractive)

> **hasInteractive**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:294](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L294)

Whether any interactive actors occupy the tile.

***

### hasProps

[Section titled “hasProps”](#hasprops)

> **hasProps**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:296](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L296)

Whether any prop actors occupy the tile.

***

### hostileActors

[Section titled “hostileActors”](#hostileactors)

> **hostileActors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:276](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L276)

Hostile actors on the tile.

***

### interactiveActors

[Section titled “interactiveActors”](#interactiveactors)

> **interactiveActors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:278](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L278)

Interactive actors on the tile.

***

### isEmpty

[Section titled “isEmpty”](#isempty)

> **isEmpty**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:288](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L288)

Whether no placements occupy the tile.

***

### occupancy

[Section titled “occupancy”](#occupancy)

> **occupancy**: readonly [`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:272](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L272)

Occupancy relation records for the tile.

***

### placements

[Section titled “placements”](#placements)

> **placements**: readonly `object`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:270](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L270)

Placements occupying the tile.

***

### propActors

[Section titled “propActors”](#propactors)

> **propActors**: readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:280](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L280)

Prop actors on the tile.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:298](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L298)

Missing or blocked reason.

***

### tags

[Section titled “tags”](#tags)

> **tags**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:268](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L268)

Tile tags, or an empty list for missing tiles.

***

### terrain?

[Section titled “terrain?”](#terrain)

> `optional` **terrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:264](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L264)

Tile terrain, when the tile exists.

***

### tile?

[Section titled “tile?”](#tile)

> `optional` **tile?**: `object`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:260](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L260)

Tile trait value, when the tile exists.

#### baseAssetId

[Section titled “baseAssetId”](#baseassetid)

> **baseAssetId**: `string` = `''`

Asset id for the visible tile top.

#### coastEdges

[Section titled “coastEdges”](#coastedges)

> **coastEdges**: `number` = `0`

Six-edge bitmask for coast connectivity.

#### coastWaterless

[Section titled “coastWaterless”](#coastwaterless)

> **coastWaterless**: `boolean` = `false`

Whether this coast tile uses the waterless guide variant.

#### coordinates

[Section titled “coordinates”](#coordinates-1)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Axial tile coordinates.

#### elevation

[Section titled “elevation”](#elevation-1)

> **elevation**: `number` = `0`

Stacked elevation level for the tile top.

#### key

[Section titled “key”](#key)

> **key**: `string` = `''`

Stable axial key in `q,r` form.

#### riverCrossing

[Section titled “riverCrossing”](#rivercrossing)

> **riverCrossing**: `"A"` | `"B"` | `undefined`

River crossing variant, when present.

#### riverCurvy

[Section titled “riverCurvy”](#rivercurvy)

> **riverCurvy**: `boolean` = `false`

Whether this river tile uses the curvy guide variant.

#### riverEdges

[Section titled “riverEdges”](#riveredges)

> **riverEdges**: `number` = `0`

Six-edge bitmask for river connectivity.

#### riverWaterless

[Section titled “riverWaterless”](#riverwaterless)

> **riverWaterless**: `boolean` = `false`

Whether this river tile uses the waterless guide variant.

#### roadEdges

[Section titled “roadEdges”](#roadedges)

> **roadEdges**: `number` = `0`

Six-edge bitmask for road connectivity.

#### roadSlope

[Section titled “roadSlope”](#roadslope)

> **roadSlope**: `"high"` | `"low"` | `undefined`

Road slope variant when a road changes elevation.

#### supportAssetId

[Section titled “supportAssetId”](#supportassetid)

> **supportAssetId**: `string` = `''`

Optional asset id for the vertical support below elevated tiles.

#### tags

[Section titled “tags”](#tags-1)

> **tags**: `string`\[]

Free-form taxonomy and generation tags.

#### terrain

[Section titled “terrain”](#terrain-1)

> **terrain**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)

Primary terrain biome represented by this tile.

#### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

KayKit texture set applied to this tile.

***

### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:258](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L258)

Inspected tile key.

# GameboardTileInspectionOptions

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:246](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L246)

Options for inspecting one board tile from an actor/gameplay perspective.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/)

## Extended by

[Section titled “Extended by”](#extended-by)

* [`GameboardNeighborhoodInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspectionoptions/)

## Properties

[Section titled “Properties”](#properties)

### blockingPlacementKinds?

[Section titled “blockingPlacementKinds?”](#blockingplacementkinds)

> `optional` **blockingPlacementKinds?**: readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L126)

Placement kinds that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`blockingPlacementKinds`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#blockingplacementkinds)

***

### blockingPlacementLayers?

[Section titled “blockingPlacementLayers?”](#blockingplacementlayers)

> `optional` **blockingPlacementLayers?**: readonly [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L128)

Placement layers that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`blockingPlacementLayers`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#blockingplacementlayers)

***

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L130)

Placement ids ignored during collision checks.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`ignorePlacementIds`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#ignoreplacementids)

***

### sourceActor?

[Section titled “sourceActor?”](#sourceactor)

> `optional` **sourceActor?**: `string` | `Entity`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:248](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L248)

Source actor used for collision interpretation.

***

### treatHostileAsBlocking?

[Section titled “treatHostileAsBlocking?”](#treathostileasblocking)

> `optional` **treatHostileAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:132](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L132)

Treat hostile actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`treatHostileAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#treathostileasblocking)

***

### treatInteractiveAsBlocking?

[Section titled “treatInteractiveAsBlocking?”](#treatinteractiveasblocking)

> `optional` **treatInteractiveAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L134)

Treat interactive actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`treatInteractiveAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#treatinteractiveasblocking)

***

### treatPropsAsBlocking?

[Section titled “treatPropsAsBlocking?”](#treatpropsasblocking)

> `optional` **treatPropsAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L136)

Treat prop actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/).[`treatPropsAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/#treatpropsasblocking)

# GameboardTileSpec

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:125](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L125)

Serializable tile state in a generated gameboard plan.

## Properties

[Section titled “Properties”](#properties)

### baseAssetId

[Section titled “baseAssetId”](#baseassetid)

> **baseAssetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:137](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L137)

Asset id for the visible tile top.

***

### coastEdges

[Section titled “coastEdges”](#coastedges)

> **coastEdges**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:145](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L145)

Six-edge bitmask for coast/water connectivity.

***

### coastWaterless

[Section titled “coastWaterless”](#coastwaterless)

> **coastWaterless**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:155](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L155)

Whether this coast tile uses a waterless variant.

***

### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:129](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L129)

Axial tile coordinates.

***

### elevation

[Section titled “elevation”](#elevation)

> **elevation**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:135](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L135)

Stacked elevation level.

***

### key

[Section titled “key”](#key)

> **key**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:127](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L127)

Stable axial tile key in `q,r` form.

***

### riverCrossing?

[Section titled “riverCrossing?”](#rivercrossing)

> `optional` **riverCrossing?**: `"A"` | `"B"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:153](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L153)

River crossing variant, when any.

***

### riverCurvy

[Section titled “riverCurvy”](#rivercurvy)

> **riverCurvy**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:151](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L151)

Whether this river tile uses a curvy variant.

***

### riverEdges

[Section titled “riverEdges”](#riveredges)

> **riverEdges**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:143](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L143)

Six-edge bitmask for river connectivity.

***

### riverWaterless

[Section titled “riverWaterless”](#riverwaterless)

> **riverWaterless**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:149](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L149)

Whether this river tile uses a waterless variant.

***

### roadEdges

[Section titled “roadEdges”](#roadedges)

> **roadEdges**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:141](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L141)

Six-edge bitmask for road connectivity.

***

### roadSlope?

[Section titled “roadSlope?”](#roadslope)

> `optional` **roadSlope?**: `"high"` | `"low"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:147](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L147)

Road slope variant when the tile uses sloped roads.

***

### supportAssetId

[Section titled “supportAssetId”](#supportassetid)

> **supportAssetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:139](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L139)

Asset id for the support/bottom under elevated tiles.

***

### tags

[Section titled “tags”](#tags)

> **tags**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:157](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L157)

Generated taxonomy tags.

***

### terrain

[Section titled “terrain”](#terrain)

> **terrain**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:131](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L131)

Primary terrain category.

***

### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:133](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L133)

KayKit texture set applied to this tile.

# GuidePermutationOptions

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:55](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L55)

Options for expanding guide tile permutation lists.

## Properties

[Section titled “Properties”](#properties)

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: readonly `number`\[]

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:57](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L57)

Rotation steps to include; defaults to all six.

***

### waterless?

[Section titled “waterless?”](#waterless)

> `optional` **waterless?**: `boolean` | `"both"`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:59](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L59)

Whether to include waterless variants, water variants, or both.

# GuideTilePermutation

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:29](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L29)

One concrete guide-described tile variant, modifier, and rotation.

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:39](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L39)

Concrete asset id to render for this permutation.

***

### canonicalMask

[Section titled “canonicalMask”](#canonicalmask)

> **canonicalMask**: `number`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:43](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L43)

Edge mask in the canonical unrotated asset orientation.

***

### curvy

[Section titled “curvy”](#curvy)

> **curvy**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:51](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L51)

Whether this permutation uses the curvy river asset variant.

***

### family

[Section titled “family”](#family)

> **family**: `"coast"` | `"road"` | `"river"`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:35](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L35)

Manifest variant family used by selectors.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:31](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L31)

Stable id for screenshots and test parametrization.

***

### inputMask

[Section titled “inputMask”](#inputmask)

> **inputMask**: `number`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:41](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L41)

Edge mask after applying the permutation rotation.

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GuideTilePermutationKind`](/declarative-hex-worlds/reference/index/type-aliases/guidetilepermutationkind/)

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L33)

Permutation family.

***

### label

[Section titled “label”](#label)

> **label**: `string`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:37](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L37)

KayKit guide label.

***

### rotationRadians

[Section titled “rotationRadians”](#rotationradians)

> **rotationRadians**: `number`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L47)

Clockwise rotation in radians.

***

### rotationSteps

[Section titled “rotationSteps”](#rotationsteps)

> **rotationSteps**: `number`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L45)

Clockwise 60-degree rotation steps.

***

### waterless

[Section titled “waterless”](#waterless)

> **waterless**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:49](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L49)

Whether this permutation uses a waterless asset variant.

# HarborBoardOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:702](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L702)

Options for the built-in medieval harbor demo board.

## Extends

[Section titled “Extends”](#extends)

* `Partial`<[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/)>

## Properties

[Section titled “Properties”](#properties)

### defaultTerrain?

[Section titled “defaultTerrain?”](#defaultterrain)

> `optional` **defaultTerrain?**: `"grass"` | `"water"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:119](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L119)

Initial terrain used for every generated tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/).[`defaultTerrain`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/#defaultterrain)

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:704](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L704)

Faction color used by settlement and harbor pieces.

***

### seed?

[Section titled “seed?”](#seed)

> `optional` **seed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:113](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L113)

Deterministic seed for generation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/).[`seed`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/#seed)

***

### shape?

[Section titled “shape?”](#shape)

> `optional` **shape?**: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:115](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L115)

Board shape to populate.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/).[`shape`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/#shape)

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:117](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L117)

Texture set applied to generated terrain.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/).[`textureSet`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/#textureset)

# HarborOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:388](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L388)

Options for adding a harbor structure and optional water props.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`AddHarborRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addharborrecipestep/)

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:390](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L390)

Coast tile where the harbor is anchored.

***

### facing

[Section titled “facing”](#facing)

> **facing**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:392](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L392)

Edge facing adjacent water.

***

### faction

[Section titled “faction”](#faction)

> **faction**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:394](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L394)

Faction color for the harbor.

***

### includeProps?

[Section titled “includeProps?”](#includeprops)

> `optional` **includeProps?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:398](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L398)

Whether to add adjacent boat/anchor props.

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`HarborKind`](/declarative-hex-worlds/reference/index/type-aliases/harborkind/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:396](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L396)

Harbor structure variant.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:400](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L400)

Clockwise 60-degree rotation steps. Defaults to `facing`.

# HexDims

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:62](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L62)

The rendered hex’s world-space footprint, used to build a textured-hex mesh whose proportions match the source sheet’s cell. Both are in world units.

## Properties

[Section titled “Properties”](#properties)

### height

[Section titled “height”](#height)

> **height**: `number`

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:64](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L64)

***

### width

[Section titled “width”](#width)

> **width**: `number`

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:63](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L63)

# HexPathOptions

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:29](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L29)

Options for A-star pathfinding over axial coordinates.

## Properties

[Section titled “Properties”](#properties)

### cost?

[Section titled “cost?”](#cost)

> `optional` **cost?**: (`from`, `to`) => `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:35](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L35)

Movement cost callback for weighted paths.

#### Parameters

[Section titled “Parameters”](#parameters)

##### from

[Section titled “from”](#from)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### to

[Section titled “to”](#to)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns)

`number`

***

### maxVisited?

[Section titled “maxVisited?”](#maxvisited)

> `optional` **maxVisited?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:37](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L37)

Maximum visited nodes before aborting the search.

***

### passable?

[Section titled “passable?”](#passable)

> `optional` **passable?**: (`coordinates`, `from?`) => `boolean`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L33)

Predicate for rejecting blocked coordinates.

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### coordinates

[Section titled “coordinates”](#coordinates)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### from?

[Section titled “from?”](#from-1)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns-1)

`boolean`

***

### shape?

[Section titled “shape?”](#shape)

> `optional` **shape?**: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:31](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L31)

Optional shape boundary; omitted paths may explore outside an authored board.

# HexPathResult

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:41](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L41)

Result from a hex pathfinding request.

## Properties

[Section titled “Properties”](#properties)

### cost

[Section titled “cost”](#cost)

> **cost**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L47)

Total path cost, or positive infinity when no path is found.

***

### found

[Section titled “found”](#found)

> **found**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:43](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L43)

Whether a complete path was found.

***

### path

[Section titled “path”](#path)

> **path**: readonly [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L45)

Ordered path from start to goal, empty when no path is found.

***

### visited

[Section titled “visited”](#visited)

> **visited**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:49](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L49)

Number of nodes visited before the search stopped.

# InMemoryGameboardEcs

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:614](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L614)

Minimal in-memory ECS useful for tests, examples, and adapter prototyping.

## Properties

[Section titled “Properties”](#properties)

### adapter

[Section titled “adapter”](#adapter)

> **adapter**: [`GameboardEcsAdapter`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsadapter/)<[`InMemoryGameboardEcsEntity`](/declarative-hex-worlds/reference/index/interfaces/inmemorygameboardecsentity/)>

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:618](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L618)

Adapter that populates `entities`.

***

### entities

[Section titled “entities”](#entities)

> **entities**: `Map`<`string`, [`InMemoryGameboardEcsEntity`](/declarative-hex-worlds/reference/index/interfaces/inmemorygameboardecsentity/)>

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:616](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L616)

Mounted entities keyed by id.

# InMemoryGameboardEcsEntity

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:600](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L600)

Entity shape used by the in-memory ECS adapter.

## Properties

[Section titled “Properties”](#properties)

### components

[Section titled “components”](#components)

> **components**: `Map`<`string`, `unknown`>

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:606](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L606)

Components keyed by component name.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:602](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L602)

Entity id.

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardInteropEntityKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteropentitykind/)

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:604](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L604)

Entity kind.

***

### relations

[Section titled “relations”](#relations)

> **relations**: [`GameboardEcsRelation`](/declarative-hex-worlds/reference/index/interfaces/gameboardecsrelation/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:608](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L608)

Outgoing relations from this entity.

# InspectGameboardPlacementOccupancyOptions

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:205](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L205)

Options for simulating whether a placement can occupy a tile footprint.

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: `string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:207](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L207)

Origin tile or tile key for the proposed placement.

***

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:215](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L215)

Placement ids ignored when checking blockers, usually the moving entity.

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:209](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L209)

Placement kind to evaluate. Defaults to `prop`.

***

### layer?

[Section titled “layer?”](#layer)

> `optional` **layer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:211](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L211)

Placement layer to evaluate. Defaults from `kind`.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:213](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L213)

Placement metadata used for footprint and occupancy rules.

***

### requireUnblocked?

[Section titled “requireUnblocked?”](#requireunblocked)

> `optional` **requireUnblocked?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:217](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L217)

Require no blockers even if the proposed placement itself is non-blocking.

# InspectSeededGameboardPieceFillsOptions

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:139](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L139)

Options for dry-running seeded piece fills.

## Properties

[Section titled “Properties”](#properties)

### seed?

[Section titled “seed?”](#seed)

> `optional` **seed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:141](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L141)

Seed used to evaluate deterministic placements.

# MarkTargetActorInteractedHandlerOptions

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:184](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L184)

Options for the actor-interaction marker handler preset.

## Properties

[Section titled “Properties”](#properties)

### commandKinds?

[Section titled “commandKinds?”](#commandkinds)

> `optional` **commandKinds?**: readonly [`GameboardInteractionCommandKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:188](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L188)

Command kinds this handler accepts.

***

### handlerId?

[Section titled “handlerId?”](#handlerid)

> `optional` **handlerId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:186](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L186)

Handler id emitted in event records.

***

### interactedField?

[Section titled “interactedField?”](#interactedfield)

> `optional` **interactedField?**: `string`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:190](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L190)

Metadata field written to the target actor.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>>

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:194](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L194)

Extra metadata merged into the target actor.

***

### sourceActorField?

[Section titled “sourceActorField?”](#sourceactorfield)

> `optional` **sourceActorField?**: `string`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:192](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L192)

Metadata field that records the source actor id.

# MountainStackOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:368](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L368)

Options for adding a stacked mountain feature.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`AddMountainStackRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addmountainstackrecipestep/)

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:370](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L370)

Tile where the mountain stack is anchored.

***

### height

[Section titled “height”](#height)

> **height**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:372](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L372)

Elevation height for the stack.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:380](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L380)

Clockwise 60-degree rotation steps.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:382](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L382)

Uniform render scale.

***

### variant?

[Section titled “variant?”](#variant)

> `optional` **variant?**: [`MountainVariant`](/declarative-hex-worlds/reference/index/type-aliases/mountainvariant/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:374](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L374)

Mountain visual variant.

***

### withGrass?

[Section titled “withGrass?”](#withgrass)

> `optional` **withGrass?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:376](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L376)

Include grass on the mountain asset.

***

### withTrees?

[Section titled “withTrees?”](#withtrees)

> `optional` **withTrees?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:378](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L378)

Include trees on the mountain asset.

# NaturePlacementOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:546](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L546)

Options for adding a nature decoration.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`AddNatureRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addnaturerecipestep/)

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `"cloud_big"` | `"cloud_small"` | `"hill_single_A"` | `"hill_single_B"` | `"hill_single_C"` | `"hills_A"` | `"hills_A_trees"` | `"hills_B"` | `"hills_B_trees"` | `"hills_C"` | `"hills_C_trees"` | `"mountain_A"` | `"mountain_A_grass"` | `"mountain_A_grass_trees"` | `"mountain_B"` | `"mountain_B_grass"` | `"mountain_B_grass_trees"` | `"mountain_C"` | `"mountain_C_grass"` | `"mountain_C_grass_trees"` | `"rock_single_A"` | `"rock_single_B"` | `"rock_single_C"` | `"rock_single_D"` | `"rock_single_E"` | `"tree_single_A"` | `"tree_single_A_cut"` | `"tree_single_B"` | `"tree_single_B_cut"` | `"trees_A_cut"` | `"trees_A_large"` | `"trees_A_medium"` | `"trees_A_small"` | `"trees_B_cut"` | `"trees_B_large"` | `"trees_B_medium"` | `"trees_B_small"` | `"waterlily_A"` | `"waterlily_B"` | `"waterplant_A"` | `"waterplant_B"` | `"waterplant_C"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:550](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L550)

Nature asset id.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:548](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L548)

Tile where the nature asset is anchored.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:552](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L552)

Clockwise 60-degree rotation steps.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:554](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L554)

Uniform render scale.

# NeutralStructureOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:438](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L438)

Options for adding a neutral structure.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`AddNeutralStructureRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addneutralstructurerecipestep/)

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:440](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L440)

Tile where the structure is anchored.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:444](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L444)

Clockwise 60-degree rotation steps.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:446](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L446)

Uniform render scale.

***

### structure

[Section titled “structure”](#structure)

> **structure**: `"projectile_catapult"` | `"building_bridge_A"` | `"building_bridge_B"` | `"building_destroyed"` | `"building_dirt"` | `"building_grain"` | `"building_scaffolding"` | `"building_stage_A"` | `"building_stage_B"` | `"building_stage_C"` | `"fence_stone_straight"` | `"fence_stone_straight_gate"` | `"fence_wood_straight"` | `"fence_wood_straight_gate"` | `"wall_corner_A_gate"` | `"wall_corner_A_inside"` | `"wall_corner_A_outside"` | `"wall_corner_B_inside"` | `"wall_corner_B_outside"` | `"wall_straight"` | `"wall_straight_gate"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:442](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L442)

Neutral structure asset id.

# Normalization

Defined in: [packages/declarative-hex-worlds/src/normalize/normalize.ts:48](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/normalize/normalize.ts#L48)

A computed normalization — a uniform scale + a recenter offset.

## Properties

[Section titled “Properties”](#properties)

### offset

[Section titled “offset”](#offset)

> `readonly` **offset**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

Defined in: [packages/declarative-hex-worlds/src/normalize/normalize.ts:55](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/normalize/normalize.ts#L55)

World-space offset to apply AFTER scaling so the (scaled) asset is centered on the cell in x/z, and rested on / centered in y per `rest`.

***

### scale

[Section titled “scale”](#scale)

> `readonly` **scale**: `number`

Defined in: [packages/declarative-hex-worlds/src/normalize/normalize.ts:50](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/normalize/normalize.ts#L50)

Uniform scale factor to apply to the asset.

# NormalizeOptions

Defined in: [packages/declarative-hex-worlds/src/normalize/normalize.ts:37](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/normalize/normalize.ts#L37)

Options for normalizing an asset to a cell.

## Properties

[Section titled “Properties”](#properties)

### fit?

[Section titled “fit?”](#fit)

> `readonly` `optional` **fit?**: [`NormalizeFit`](/declarative-hex-worlds/reference/index/type-aliases/normalizefit/)

Defined in: [packages/declarative-hex-worlds/src/normalize/normalize.ts:38](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/normalize/normalize.ts#L38)

***

### rest?

[Section titled “rest?”](#rest)

> `readonly` `optional` **rest?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/normalize/normalize.ts:44](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/normalize/normalize.ts#L44)

Rest the asset ON the cell surface (its min-Y sits at y=0) after scaling, rather than centering it vertically. Default true — props/buildings stand on the tile.

***

### target?

[Section titled “target?”](#target)

> `readonly` `optional` **target?**: [`NormalizeTarget`](/declarative-hex-worlds/reference/index/interfaces/normalizetarget/)

Defined in: [packages/declarative-hex-worlds/src/normalize/normalize.ts:39](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/normalize/normalize.ts#L39)

# NormalizeTarget

Defined in: [packages/declarative-hex-worlds/src/normalize/normalize.ts:29](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/normalize/normalize.ts#L29)

The board cell an asset is normalized to (defaults to the KayKit hex cell).

## Properties

[Section titled “Properties”](#properties)

### depth?

[Section titled “depth?”](#depth)

> `readonly` `optional` **depth?**: `number`

Defined in: [packages/declarative-hex-worlds/src/normalize/normalize.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/normalize/normalize.ts#L33)

Target cell depth in world units (z).

***

### width?

[Section titled “width?”](#width)

> `readonly` `optional` **width?**: `number`

Defined in: [packages/declarative-hex-worlds/src/normalize/normalize.ts:31](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/normalize/normalize.ts#L31)

Target cell width in world units (x).

# OverlayAnchor

Defined in: [packages/declarative-hex-worlds/src/overlay/overlay.ts:21](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/overlay/overlay.ts#L21)

Where on the cell the asset anchors, as a fraction of the cell (0.5,0.5 = center; 0,0 = a corner). Applied on the board plane (x = width, z = depth) before offset.

## Properties

[Section titled “Properties”](#properties)

### x?

[Section titled “x?”](#x)

> `readonly` `optional` **x?**: `number`

Defined in: [packages/declarative-hex-worlds/src/overlay/overlay.ts:22](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/overlay/overlay.ts#L22)

***

### z?

[Section titled “z?”](#z)

> `readonly` `optional` **z?**: `number`

Defined in: [packages/declarative-hex-worlds/src/overlay/overlay.ts:23](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/overlay/overlay.ts#L23)

# OverlayControls

Defined in: [packages/declarative-hex-worlds/src/overlay/overlay.ts:27](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/overlay/overlay.ts#L27)

Dev-controllable overlay controls layered on top of the normalization.

## Properties

[Section titled “Properties”](#properties)

### anchor?

[Section titled “anchor?”](#anchor)

> `readonly` `optional` **anchor?**: [`OverlayAnchor`](/declarative-hex-worlds/reference/index/interfaces/overlayanchor/)

Defined in: [packages/declarative-hex-worlds/src/overlay/overlay.ts:29](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/overlay/overlay.ts#L29)

Anchor within the cell (default center 0.5,0.5).

***

### cell?

[Section titled “cell?”](#cell)

> `readonly` `optional` **cell?**: `object`

Defined in: [packages/declarative-hex-worlds/src/overlay/overlay.ts:37](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/overlay/overlay.ts#L37)

The cell the anchor is measured against (default KayKit hex).

#### depth?

[Section titled “depth?”](#depth)

> `readonly` `optional` **depth?**: `number`

#### width?

[Section titled “width?”](#width)

> `readonly` `optional` **width?**: `number`

***

### offset?

[Section titled “offset?”](#offset)

> `readonly` `optional` **offset?**: `Partial`<[`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)>

Defined in: [packages/declarative-hex-worlds/src/overlay/overlay.ts:31](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/overlay/overlay.ts#L31)

Additional world-space nudge applied after anchoring.

***

### rotationY?

[Section titled “rotationY?”](#rotationy)

> `readonly` `optional` **rotationY?**: `number`

Defined in: [packages/declarative-hex-worlds/src/overlay/overlay.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/overlay/overlay.ts#L33)

Additional Y rotation (radians) on top of the placement rotation.

***

### scale?

[Section titled “scale?”](#scale)

> `readonly` `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/overlay/overlay.ts:35](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/overlay/overlay.ts#L35)

Multiplier on the normalized scale (1 = normalized size).

# PlacementOccupancySnapshot

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:185](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L185)

Serializable occupancy record joined from a placement and an occupied tile.

## Properties

[Section titled “Properties”](#properties)

### blocksMovement

[Section titled “blocksMovement”](#blocksmovement)

> **blocksMovement**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:197](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L197)

Whether this occupancy record blocks movement.

***

### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:189](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L189)

Axial coordinates for the occupied tile.

***

### footprintIndex

[Section titled “footprintIndex”](#footprintindex)

> **footprintIndex**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:195](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L195)

Zero-based index within the placement footprint.

***

### occupancyGroup

[Section titled “occupancyGroup”](#occupancygroup)

> **occupancyGroup**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:199](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L199)

Occupancy group used to allow compatible colocated placements.

***

### originTileKey

[Section titled “originTileKey”](#origintilekey)

> **originTileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:193](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L193)

Origin tile key for the placement.

***

### placement

[Section titled “placement”](#placement)

> **placement**: `object`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:191](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L191)

Placement occupying the tile.

#### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string` = `''`

Manifest or external registry asset id.

#### coordinates

[Section titled “coordinates”](#coordinates-1)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Axial coordinates of the origin tile.

#### elevation

[Section titled “elevation”](#elevation)

> **elevation**: `number` = `0`

Base tile elevation where the placement was spawned.

#### elevationOffset

[Section titled “elevationOffset”](#elevationoffset)

> **elevationOffset**: `number` = `0`

Extra vertical offset above the tile elevation.

#### id

[Section titled “id”](#id)

> **id**: `string` = `''`

Stable placement id.

#### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Gameplay category for rules, selectors, and rendering.

#### layer

[Section titled “layer”](#layer)

> **layer**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Render and occupancy layer.

#### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Record`<`string`, `string` | `number` | `boolean` | `null`>

Serializable placement metadata for rules, ECS interop, and render hints.

#### order

[Section titled “order”](#order)

> **order**: `number` = `0`

Stable sort order used by renderers and snapshots.

#### position

[Section titled “position”](#position)

> **position**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

World-space placement anchor after elevation and local offsets.

#### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean` = `false`

Whether the placement depends on local-only EXTRA assets.

#### rotationRadians

[Section titled “rotationRadians”](#rotationradians)

> **rotationRadians**: `number` = `0`

Rotation in radians derived from `rotationSteps`.

#### rotationSteps

[Section titled “rotationSteps”](#rotationsteps)

> **rotationSteps**: `number` = `0`

Clockwise 60-degree rotation steps.

#### scale

[Section titled “scale”](#scale)

> **scale**: `number` = `1`

Uniform render scale.

#### stackIndex

[Section titled “stackIndex”](#stackindex)

> **stackIndex**: `number` | `undefined`

Optional stack index for layered terrain and vertical props.

#### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

KayKit texture set applied to this placement.

#### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string` = `''`

Origin tile key in `q,r` form.

***

### tileKey

[Section titled “tileKey”](#tilekey-1)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:187](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L187)

Tile key for the occupied tile.

# PlacementOccupancyValue

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:171](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L171)

Stored relation payload for one tile occupied by one placement.

## Properties

[Section titled “Properties”](#properties)

### blocksMovement

[Section titled “blocksMovement”](#blocksmovement)

> **blocksMovement**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:177](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L177)

Whether this footprint record blocks movement.

***

### footprintIndex

[Section titled “footprintIndex”](#footprintindex)

> **footprintIndex**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:175](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L175)

Zero-based index within the footprint key list.

***

### occupancyGroup

[Section titled “occupancyGroup”](#occupancygroup)

> **occupancyGroup**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:179](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L179)

Occupancy group used to allow compatible colocated placements.

***

### originTileKey

[Section titled “originTileKey”](#origintilekey)

> **originTileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:173](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L173)

Origin tile key for the placement that owns this footprint record.

# PngDimensions

Defined in: [packages/declarative-hex-worlds/src/asset-source/png-dimensions.ts:18](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/png-dimensions.ts#L18)

A PNG’s pixel dimensions.

## Properties

[Section titled “Properties”](#properties)

### height

[Section titled “height”](#height)

> **height**: `number`

Defined in: [packages/declarative-hex-worlds/src/asset-source/png-dimensions.ts:20](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/png-dimensions.ts#L20)

***

### width

[Section titled “width”](#width)

> **width**: `number`

Defined in: [packages/declarative-hex-worlds/src/asset-source/png-dimensions.ts:19](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/png-dimensions.ts#L19)

# PropClusterOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:574](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L574)

Options for adding a semantic cluster of props.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`AddPropClusterRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/)

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:576](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L576)

Anchor tile for the cluster.

***

### clusterId?

[Section titled “clusterId?”](#clusterid)

> `optional` **clusterId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:588](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L588)

Optional stable id shared by all placements in the cluster.

***

### density?

[Section titled “density?”](#density)

> `optional` **density?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:584](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L584)

Percentage of the cluster’s available asset list to place, from 0 to 1. Defaults to 1.

***

### facing?

[Section titled “facing?”](#facing)

> `optional` **facing?**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:580](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L580)

Edge used to orient adjacent spread patterns.

***

### includeExtra?

[Section titled “includeExtra?”](#includeextra)

> `optional` **includeExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:586](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L586)

Include local-only EXTRA prop assets when the cluster kind has them. Defaults to false.

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`PropClusterKind`](/declarative-hex-worlds/reference/index/type-aliases/propclusterkind/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:578](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L578)

Cluster purpose. Determines the default asset list.

***

### placement?

[Section titled “placement?”](#placement)

> `optional` **placement?**: [`PropClusterPlacement`](/declarative-hex-worlds/reference/index/type-aliases/propclusterplacement/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:582](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L582)

Whether assets stack on one tile or spread to neighboring tiles. Defaults to `adjacent`.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:590](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L590)

Base clockwise 60-degree rotation steps. Defaults to `facing`.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:592](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L592)

Uniform render scale.

# PropPlacementOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:560](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L560)

Options for adding a prop placement.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`AddPropRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addproprecipestep/)

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `"tent"` | `"anchor"` | `"barrel"` | `"boat"` | `"boatrack"` | `"bucket_arrows"` | `"bucket_empty"` | `"bucket_water"` | `"cannonball_pallet"` | `"crate_A_big"` | `"crate_A_small"` | `"crate_B_big"` | `"crate_B_small"` | `"crate_long_A"` | `"crate_long_B"` | `"crate_long_C"` | `"crate_long_empty"` | `"crate_open"` | `"flag_blue"` | `"flag_green"` | `"flag_red"` | `"flag_yellow"` | `"haybale"` | `"icon_combat"` | `"icon_range"` | `"ladder"` | `"pallet"` | `"resource_lumber"` | `"resource_stone"` | `"sack"` | `"target"` | `"trough"` | `"trough_long"` | `"weaponrack"` | `"wheelbarrow"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:564](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L564)

Prop asset id.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:562](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L562)

Tile where the prop is anchored.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:566](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L566)

Clockwise 60-degree rotation steps.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:568](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L568)

Uniform render scale.

# RemoveTargetActorHandlerOptions

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:160](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L160)

Options for the actor-removal handler preset.

## Properties

[Section titled “Properties”](#properties)

### commandKinds?

[Section titled “commandKinds?”](#commandkinds)

> `optional` **commandKinds?**: readonly [`GameboardInteractionCommandKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:164](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L164)

Command kinds this handler accepts.

***

### handlerId?

[Section titled “handlerId?”](#handlerid)

> `optional` **handlerId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:162](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L162)

Handler id emitted in event records.

***

### requireHostile?

[Section titled “requireHostile?”](#requirehostile)

> `optional` **requireHostile?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:166](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L166)

Require the target to be hostile to the source actor.

# RemoveTargetPlacementHandlerOptions

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:172](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L172)

Options for the placement-removal handler preset.

## Properties

[Section titled “Properties”](#properties)

### commandKinds?

[Section titled “commandKinds?”](#commandkinds)

> `optional` **commandKinds?**: readonly [`GameboardInteractionCommandKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:176](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L176)

Command kinds this handler accepts.

***

### handlerId?

[Section titled “handlerId?”](#handlerid)

> `optional` **handlerId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:174](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L174)

Handler id emitted in event records.

***

### includeActorPlacements?

[Section titled “includeActorPlacements?”](#includeactorplacements)

> `optional` **includeActorPlacements?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:178](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L178)

Permit actor placements to be removed by this placement handler.

# ResolveContext

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:155](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L155)

Context passed to an `AssetSource` when resolving a placement. Carries the optional asset-root base URL (for resolving relative sheet/model paths) and is open for future resolution inputs without changing the interface signature.

## Properties

[Section titled “Properties”](#properties)

### baseUrl?

[Section titled “baseUrl?”](#baseurl)

> `optional` **baseUrl?**: `string` | `URL`

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:157](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L157)

Base URL for resolving a source’s relative asset paths (models, sheets).

# ResolvedAccessoryTransform

Defined in: [packages/declarative-hex-worlds/src/accessories/accessories.ts:40](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/accessories/accessories.ts#L40)

A resolved accessory local transform with every field defaulted.

## Properties

[Section titled “Properties”](#properties)

### position

[Section titled “position”](#position)

> `readonly` **position**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

Defined in: [packages/declarative-hex-worlds/src/accessories/accessories.ts:41](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/accessories/accessories.ts#L41)

***

### rotation

[Section titled “rotation”](#rotation)

> `readonly` **rotation**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

Defined in: [packages/declarative-hex-worlds/src/accessories/accessories.ts:42](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/accessories/accessories.ts#L42)

***

### scale

[Section titled “scale”](#scale)

> `readonly` **scale**: `number`

Defined in: [packages/declarative-hex-worlds/src/accessories/accessories.ts:43](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/accessories/accessories.ts#L43)

# ResolvedGameboardScenarioActor

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:70](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L70)

Scenario actor after spawn group references have been resolved.

## Extends

[Section titled “Extends”](#extends)

* [`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/)

## Properties

[Section titled “Properties”](#properties)

### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:54](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L54)

Stable gameplay actor id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`actorId`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#actorid)

***

### actorKind?

[Section titled “actorKind?”](#actorkind)

> `optional` **actorKind?**: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:56](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L56)

Gameplay actor kind. Defaults from placement kind.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`actorKind`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#actorkind)

***

### actorMetadata?

[Section titled “actorMetadata?”](#actormetadata)

> `optional` **actorMetadata?**: `Readonly`<`Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:70](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L70)

Serializable actor metadata independent from placement metadata.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`actorMetadata`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#actormetadata)

***

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:302](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L302)

Manifest or external registry asset id to render.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`assetId`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#assetid)

***

### at

[Section titled “at”](#at)

> **at**: `string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:300](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L300)

Origin tile or tile key where the placement should spawn.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#at)

***

### blocksMovement?

[Section titled “blocksMovement?”](#blocksmovement)

> `optional` **blocksMovement?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:64](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L64)

Whether this actor blocks actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`blocksMovement`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#blocksmovement)

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:310](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L310)

Extra vertical offset above the tile elevation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`elevationOffset`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#elevationoffset)

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `string` | `null`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L58)

Optional faction identifier.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`faction`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#faction)

***

### hostile?

[Section titled “hostile?”](#hostile)

> `optional` **hostile?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:62](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L62)

Whether this actor is generally hostile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`hostile`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#hostile)

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:298](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L298)

Explicit placement id. Defaults to a deterministic runtime id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`id`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#id)

***

### interactive?

[Section titled “interactive?”](#interactive)

> `optional` **interactive?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:66](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L66)

Whether this actor should be considered an interaction target.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`interactive`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#interactive)

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:304](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L304)

Gameplay category for rules, selectors, and rendering.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`kind`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#kind)

***

### layer?

[Section titled “layer?”](#layer)

> `optional` **layer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:306](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L306)

Render and occupancy layer. Defaults from `kind`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`layer`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#layer)

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:324](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L324)

Serializable placement metadata for rules, ECS interop, and render hints.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`metadata`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#metadata)

***

### movementAgent?

[Section titled “movementAgent?”](#movementagent)

> `optional` **movementAgent?**: [`SetGameboardMovementAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardmovementagentoptions/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:80](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L80)

Optional movement agent to attach after spawning.

***

### occupancyGuard?

[Section titled “occupancyGuard?”](#occupancyguard)

> `optional` **occupancyGuard?**: [`GameboardPlacementOccupancyGuard`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementoccupancyguard/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:326](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L326)

Optional occupancy validation before spawning.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-14)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`occupancyGuard`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#occupancyguard)

***

### order?

[Section titled “order?”](#order)

> `optional` **order?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:318](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L318)

Stable sort order used by renderers and snapshots.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-15)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`order`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#order)

***

### patrolAgent?

[Section titled “patrolAgent?”](#patrolagent)

> `optional` **patrolAgent?**: [`GameboardScenarioActorPatrolAgent`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenarioactorpatrolagent/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:82](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L82)

Optional patrol agent to attach after spawning.

***

### positionOffset?

[Section titled “positionOffset?”](#positionoffset)

> `optional` **positionOffset?**: [`GameboardPlacementPositionOffset`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementpositionoffset/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:312](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L312)

Local world-space offset after tile/elevation anchoring.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-16)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`positionOffset`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#positionoffset)

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:322](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L322)

Whether the placement depends on local-only EXTRA assets.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-17)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`requiresExtra`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#requiresextra)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:314](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L314)

Clockwise 60-degree rotation steps.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-18)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:316](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L316)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-19)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#scale)

***

### spawnGroupId?

[Section titled “spawnGroupId?”](#spawngroupid)

> `optional` **spawnGroupId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:72](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L72)

Spawn group id used to resolve the actor, when any.

***

### spawnLocationId?

[Section titled “spawnLocationId?”](#spawnlocationid)

> `optional` **spawnLocationId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:76](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L76)

Spawn location id claimed inside the group, when any.

***

### spawnLocationIndex?

[Section titled “spawnLocationIndex?”](#spawnlocationindex)

> `optional` **spawnLocationIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:74](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L74)

Spawn location index claimed inside the group, when any.

***

### spawnTileKey?

[Section titled “spawnTileKey?”](#spawntilekey)

> `optional` **spawnTileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:78](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L78)

Spawn tile key claimed inside the group, when any.

***

### stackIndex?

[Section titled “stackIndex?”](#stackindex)

> `optional` **stackIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:320](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L320)

Optional stack index for layered terrain and vertical props.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-20)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`stackIndex`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#stackindex)

***

### tags?

[Section titled “tags?”](#tags)

> `optional` **tags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:68](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L68)

Free-form actor tags used by selectors and quests.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-21)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`tags`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#tags)

***

### team?

[Section titled “team?”](#team)

> `optional` **team?**: `string` | `null`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:60](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L60)

Optional team identifier. Defaults to faction when omitted.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-22)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`team`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#team)

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:308](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L308)

Texture set override. Defaults to the origin tile texture set.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-23)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/).[`textureSet`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/#textureset)

# RunGameboardActorTargetInteractionResult

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:68](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L68)

Result of target selection, command dispatch, and optional system advancement.

## Properties

[Section titled “Properties”](#properties)

### dispatch?

[Section titled “dispatch?”](#dispatch)

> `optional` **dispatch?**: [`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:74](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L74)

Dispatch result when command dispatch occurred.

***

### eventRecords

[Section titled “eventRecords”](#eventrecords)

> **eventRecords**: readonly [`GameboardSystemEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardsystemeventrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:80](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L80)

Serializable event records derived from `events`.

***

### events

[Section titled “events”](#events)

> **events**: readonly [`GameboardSystemEvent`](/declarative-hex-worlds/reference/index/type-aliases/gameboardsystemevent/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:78](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L78)

Combined dispatch and system events.

***

### interaction?

[Section titled “interaction?”](#interaction)

> `optional` **interaction?**: [`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:72](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L72)

Interaction result when the target command was executable.

***

### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:82](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L82)

Reason no interaction occurred or dispatch was blocked.

***

### systems?

[Section titled “systems?”](#systems)

> `optional` **systems?**: [`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:76](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L76)

System result when systems were enabled.

***

### targetCommand

[Section titled “targetCommand”](#targetcommand)

> **targetCommand**: [`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:70](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L70)

Actor-target command plan.

# RunGameboardInteractionOptions

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:46](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L46)

Options for dispatching a command and then optionally running systems.

## Extends

[Section titled “Extends”](#extends)

* [`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/)

## Properties

[Section titled “Properties”](#properties)

### blockingPlacementKinds?

[Section titled “blockingPlacementKinds?”](#blockingplacementkinds)

> `optional` **blockingPlacementKinds?**: readonly [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L126)

Placement kinds that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/).[`blockingPlacementKinds`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/#blockingplacementkinds)

***

### blockingPlacementLayers?

[Section titled “blockingPlacementLayers?”](#blockingplacementlayers)

> `optional` **blockingPlacementLayers?**: readonly [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L128)

Placement layers that should block actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/).[`blockingPlacementLayers`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/#blockingplacementlayers)

***

### handlers?

[Section titled “handlers?”](#handlers)

> `optional` **handlers?**: [`GameboardInteractionHandler`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandler/) | readonly [`GameboardInteractionHandler`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandler/)\[]

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:240](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L240)

Handler or handler chain for non-movement interact/attack/inspect commands.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/).[`handlers`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/#handlers)

***

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L130)

Placement ids ignored during collision checks.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/).[`ignorePlacementIds`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/#ignoreplacementids)

***

### movement?

[Section titled “movement?”](#movement)

> `optional` **movement?**: [`GameboardMovementPathRequestOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementpathrequestoptions/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:231](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L231)

Movement path options used when the command is a move request.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/).[`movement`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/#movement)

***

### requireSourceActorForAttack?

[Section titled “requireSourceActorForAttack?”](#requiresourceactorforattack)

> `optional` **requireSourceActorForAttack?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:572](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L572)

Require a source actor before attack commands can execute.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/).[`requireSourceActorForAttack`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/#requiresourceactorforattack)

***

### requireSourceActorForInteraction?

[Section titled “requireSourceActorForInteraction?”](#requiresourceactorforinteraction)

> `optional` **requireSourceActorForInteraction?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:574](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L574)

Require a source actor before interaction commands can execute.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/).[`requireSourceActorForInteraction`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/#requiresourceactorforinteraction)

***

### requireSourceActorForMove?

[Section titled “requireSourceActorForMove?”](#requiresourceactorformove)

> `optional` **requireSourceActorForMove?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:570](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L570)

Require a source actor before move commands can execute.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/).[`requireSourceActorForMove`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/#requiresourceactorformove)

***

### sourceActor?

[Section titled “sourceActor?”](#sourceactor)

> `optional` **sourceActor?**: `string` | `Entity`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:216](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L216)

Source actor used for hostility and collision interpretation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/).[`sourceActor`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/#sourceactor)

***

### systems?

[Section titled “systems?”](#systems)

> `optional` **systems?**: `false` | [`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:48](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L48)

Systems to run after dispatch, or false to only dispatch the command.

***

### treatHostileAsBlocking?

[Section titled “treatHostileAsBlocking?”](#treathostileasblocking)

> `optional` **treatHostileAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:132](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L132)

Treat hostile actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/).[`treatHostileAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/#treathostileasblocking)

***

### treatInteractiveAsBlocking?

[Section titled “treatInteractiveAsBlocking?”](#treatinteractiveasblocking)

> `optional` **treatInteractiveAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L134)

Treat interactive actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/).[`treatInteractiveAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/#treatinteractiveasblocking)

***

### treatPropsAsBlocking?

[Section titled “treatPropsAsBlocking?”](#treatpropsasblocking)

> `optional` **treatPropsAsBlocking?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L136)

Treat prop actors as movement blockers.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/).[`treatPropsAsBlocking`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/#treatpropsasblocking)

# RunGameboardInteractionResult

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:54](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L54)

Result of command dispatch plus optional system advancement.

## Properties

[Section titled “Properties”](#properties)

### dispatch

[Section titled “dispatch”](#dispatch)

> **dispatch**: [`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:56](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L56)

Command dispatch result.

***

### eventRecords

[Section titled “eventRecords”](#eventrecords)

> **eventRecords**: readonly [`GameboardSystemEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardsystemeventrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:62](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L62)

Serializable event records derived from `events`.

***

### events

[Section titled “events”](#events)

> **events**: readonly [`GameboardSystemEvent`](/declarative-hex-worlds/reference/index/type-aliases/gameboardsystemevent/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:60](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L60)

Combined dispatch and system events.

***

### systems?

[Section titled “systems?”](#systems)

> `optional` **systems?**: [`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L58)

System result when systems were enabled.

# RunGameboardScenarioSimulationOptions

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:588](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L588)

Options for running a scenario simulation.

## Properties

[Section titled “Properties”](#properties)

### defaultCommandHandlerOptions?

[Section titled “defaultCommandHandlerOptions?”](#defaultcommandhandleroptions)

> `optional` **defaultCommandHandlerOptions?**: [`CreateGameboardInteractionHandlerPresetOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardinteractionhandlerpresetoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:598](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L598)

Default options for built-in command handler presets.

***

### defaultCommandHandlers?

[Section titled “defaultCommandHandlers?”](#defaultcommandhandlers)

> `optional` **defaultCommandHandlers?**: readonly (`"remove-target-actor"` | `"remove-target-placement"` | `"mark-target-interacted"` | `"default-rpg"`)\[]

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:596](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L596)

Default built-in command handler presets.

***

### defaultCommandSystems?

[Section titled “defaultCommandSystems?”](#defaultcommandsystems)

> `optional` **defaultCommandSystems?**: `false` | [`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:594](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L594)

Default systems after command dispatch, or false to skip.

***

### defaultRunSystems?

[Section titled “defaultRunSystems?”](#defaultrunsystems)

> `optional` **defaultRunSystems?**: [`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:600](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L600)

Default systems for run-systems steps.

***

### defaultSourceActor?

[Section titled “defaultSourceActor?”](#defaultsourceactor)

> `optional` **defaultSourceActor?**: `string`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:592](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L592)

Default source actor id for command steps.

***

### recipeOverrides?

[Section titled “recipeOverrides?”](#recipeoverrides)

> `optional` **recipeOverrides?**: `Partial`<[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/)>

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:590](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L590)

Recipe compile overrides for the scenario board.

# RunGameboardSystemsOptions

Defined in: [packages/declarative-hex-worlds/src/systems/tick.ts:32](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/tick.ts#L32)

System tick options. Set a subsystem to false to skip it for this tick.

## Properties

[Section titled “Properties”](#properties)

### movement?

[Section titled “movement?”](#movement)

> `optional` **movement?**: `false` | [`AdvanceGameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardmovementoptions/)

Defined in: [packages/declarative-hex-worlds/src/systems/tick.ts:36](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/tick.ts#L36)

Movement advancement options or false to skip movement.

***

### patrols?

[Section titled “patrols?”](#patrols)

> `optional` **patrols?**: `false` | [`AdvanceGameboardPatrolOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardpatroloptions/)

Defined in: [packages/declarative-hex-worlds/src/systems/tick.ts:34](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/tick.ts#L34)

Patrol advancement options or false to skip patrols.

***

### quests?

[Section titled “quests?”](#quests)

> `optional` **quests?**: `false` | [`AdvanceGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardquestoptions/)

Defined in: [packages/declarative-hex-worlds/src/systems/tick.ts:38](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/tick.ts#L38)

Quest advancement options or false to skip quests.

# RunGameboardSystemsResult

Defined in: [packages/declarative-hex-worlds/src/systems/tick.ts:44](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/tick.ts#L44)

Result of running patrol, movement, and quest systems.

## Properties

[Section titled “Properties”](#properties)

### eventRecords

[Section titled “eventRecords”](#eventrecords)

> **eventRecords**: readonly [`GameboardSystemEventRecord`](/declarative-hex-worlds/reference/index/interfaces/gameboardsystemeventrecord/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/tick.ts:54](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/tick.ts#L54)

Serializable event records derived from `events`.

***

### events

[Section titled “events”](#events)

> **events**: readonly [`GameboardSystemEvent`](/declarative-hex-worlds/reference/index/type-aliases/gameboardsystemevent/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/tick.ts:52](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/tick.ts#L52)

In-memory events emitted by all enabled systems.

***

### movement

[Section titled “movement”](#movement)

> **movement**: readonly [`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/tick.ts:48](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/tick.ts#L48)

Movement results produced by this tick.

***

### patrols

[Section titled “patrols”](#patrols)

> **patrols**: readonly [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/tick.ts:46](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/tick.ts#L46)

Patrol results produced by this tick.

***

### quests

[Section titled “quests”](#quests)

> **quests**: readonly [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/tick.ts:50](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/tick.ts#L50)

Quest snapshots after advancement.

# ScannedAsset

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:22](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L22)

A candidate asset record the scanner produced (before spec validation).

## Properties

[Section titled “Properties”](#properties)

### format

[Section titled “format”](#format)

> `readonly` **format**: `"png"` | `"glb"` | `"gltf"`

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:25](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L25)

***

### id

[Section titled “id”](#id)

> `readonly` **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:23](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L23)

***

### path

[Section titled “path”](#path)

> `readonly` **path**: `string`

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:26](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L26)

***

### role

[Section titled “role”](#role)

> `readonly` **role**: `"tile"` | `"model"` | `"tileset"` | `"sprite"`

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:24](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L24)

# ScannedFile

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:17](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L17)

A discovered asset file, path relative to the source root (forward slashes).

## Properties

[Section titled “Properties”](#properties)

### path

[Section titled “path”](#path)

> `readonly` **path**: `string`

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:18](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L18)

# ScanResult

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:30](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L30)

The outcome of scanning a file list.

## Properties

[Section titled “Properties”](#properties)

### assets

[Section titled “assets”](#assets)

> `readonly` **assets**: readonly [`ScannedAsset`](/declarative-hex-worlds/reference/index/interfaces/scannedasset/)\[]

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:32](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L32)

Classified assets (tilesets appear here but need a grid before the spec validates).

***

### skipped

[Section titled “skipped”](#skipped)

> `readonly` **skipped**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:34](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L34)

Paths that could not be classified (unknown subdir or unsupported extension).

***

### tilesetsNeedingGrid

[Section titled “tilesetsNeedingGrid”](#tilesetsneedinggrid)

> `readonly` **tilesetsNeedingGrid**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:36](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L36)

Ids of tileset assets that still need author-supplied grid dimensions.

***

### tilesNeedingBiome

[Section titled “tilesNeedingBiome”](#tilesneedingbiome)

> `readonly` **tilesNeedingBiome**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:38](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L38)

Ids of tile assets whose biome was guessed as `'unknown'` (author should fix).

# ScatterDecorationOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:686](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L686)

Options for seeded random decoration scatter.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`ScatterDecorationsRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/scatterdecorationsrecipestep/)

## Properties

[Section titled “Properties”](#properties)

### assets

[Section titled “assets”](#assets)

> **assets**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:690](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L690)

Candidate asset ids for each decoration.

***

### avoidOccupied?

[Section titled “avoidOccupied?”](#avoidoccupied)

> `optional` **avoidOccupied?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:694](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L694)

Avoid tiles with existing custom placements.

***

### count

[Section titled “count”](#count)

> **count**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:688](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L688)

Number of decorations to place.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:696](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L696)

Uniform render scale.

***

### terrain?

[Section titled “terrain?”](#terrain)

> `optional` **terrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/) | readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:692](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L692)

Allowed terrain for decoration sites.

# SeededGameboardDensityContext

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:100](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L100)

Context used while expanding built-in density presets.

## Properties

[Section titled “Properties”](#properties)

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:102](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L102)

Faction used for faction-colored preset assets.

# SeededGameboardDensityRuleOptions

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L67)

Overrides for one built-in seeded density preset.

## Extends

[Section titled “Extends”](#extends)

* `Omit`<[`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/), `"archetype"` | `"assetId"` | `"assets"` | `"count"` | `"fill"` | `"id"`>

## Properties

[Section titled “Properties”](#properties)

### archetype?

[Section titled “archetype?”](#archetype)

> `optional` **archetype?**: [`GameboardLayoutArchetypeInput`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/gameboardlayoutarchetypeinput/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:80](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L80)

Archetype id or inline archetype to use for placement constraints.

***

### archetypes?

[Section titled “archetypes?”](#archetypes)

> `optional` **archetypes?**: `Readonly`<`Record`<`string`, [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)>>

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:432](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L432)

Registry used to resolve `archetype`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/).[`archetypes`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/#archetypes)

***

### assetId?

[Section titled “assetId?”](#assetid)

> `optional` **assetId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:72](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L72)

Single asset id to spawn for the preset.

***

### assets?

[Section titled “assets?”](#assets)

> `optional` **assets?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:74](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L74)

Asset pool to choose from for the preset.

***

### count?

[Section titled “count?”](#count)

> `optional` **count?**: `number`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:76](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L76)

Exact placement count for the preset.

***

### criteria?

[Section titled “criteria?”](#criteria)

> `optional` **criteria?**: [`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:446](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L446)

Criteria merged over archetype defaults.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/).[`criteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/#criteria)

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:310](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L310)

Extra vertical offset above the tile elevation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`elevationOffset`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#elevationoffset)

***

### fill?

[Section titled “fill?”](#fill)

> `optional` **fill?**: `number`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:78](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L78)

Fraction of eligible tiles to fill for the preset.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:70](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L70)

Explicit fill rule id.

***

### idPrefix?

[Section titled “idPrefix?”](#idprefix)

> `optional` **idPrefix?**: `string`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:477](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L477)

Prefix used when assigning deterministic placement ids.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/).[`idPrefix`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/#idprefix)

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:434](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L434)

Placement kind override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/).[`kind`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/#kind)

***

### layer?

[Section titled “layer?”](#layer)

> `optional` **layer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:436](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L436)

Placement layer override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/).[`layer`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/#layer)

***

### maxCount?

[Section titled “maxCount?”](#maxcount)

> `optional` **maxCount?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:475](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L475)

Maximum placement count after fill/count calculation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/).[`maxCount`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/#maxcount)

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:324](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L324)

Serializable placement metadata for rules, ECS interop, and render hints.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`metadata`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#metadata)

***

### minCount?

[Section titled “minCount?”](#mincount)

> `optional` **minCount?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:473](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L473)

Minimum placement count after fill/count calculation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/).[`minCount`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/#mincount)

***

### occupancyGuard?

[Section titled “occupancyGuard?”](#occupancyguard)

> `optional` **occupancyGuard?**: [`GameboardPlacementOccupancyGuard`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementoccupancyguard/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:326](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L326)

Optional occupancy validation before spawning.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`occupancyGuard`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#occupancyguard)

***

### onDiagnostics?

[Section titled “onDiagnostics?”](#ondiagnostics)

> `optional` **onDiagnostics?**: (`diagnostics`) => `void`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:454](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L454)

Called when the selected site count is less than the requested `count` (including zero). Reports the resolved criteria and a rejection histogram so an empty result is distinguishable from “board is full”. Never called when `selectedCount >= requestedCount`. No-op by default — absent option means zero behavior change.

#### Parameters

[Section titled “Parameters”](#parameters)

##### diagnostics

[Section titled “diagnostics”](#diagnostics)

[`GameboardLayoutPlacementDiagnostics`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementdiagnostics/)

#### Returns

[Section titled “Returns”](#returns)

`void`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

`Omit.onDiagnostics`

***

### order?

[Section titled “order?”](#order)

> `optional` **order?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:318](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L318)

Stable sort order used by renderers and snapshots.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`order`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#order)

***

### positionOffset?

[Section titled “positionOffset?”](#positionoffset)

> `optional` **positionOffset?**: [`GameboardPlacementPositionOffset`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementpositionoffset/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:312](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L312)

Local world-space offset after tile/elevation anchoring.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`positionOffset`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#positionoffset)

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:322](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L322)

Whether the placement depends on local-only EXTRA assets.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`requiresExtra`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#requiresextra)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number` | `"random"`

Defined in: [packages/declarative-hex-worlds/src/coordinates/layout.ts:444](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/layout.ts#L444)

Rotation steps or deterministic random rotation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-14)

`Omit.rotationSteps`

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:316](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L316)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-15)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#scale)

***

### stackIndex?

[Section titled “stackIndex?”](#stackindex)

> `optional` **stackIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:320](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L320)

Optional stack index for layered terrain and vertical props.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-16)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`stackIndex`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#stackindex)

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:308](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L308)

Texture set override. Defaults to the origin tile texture set.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-17)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`textureSet`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#textureset)

# SeededGameboardLayoutDensityOptions

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:84](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L84)

Density controls for built-in seeded board fill presets.

## Properties

[Section titled “Properties”](#properties)

### harbors?

[Section titled “harbors?”](#harbors)

> `optional` **harbors?**: [`SeededGameboardDensityValue`](/declarative-hex-worlds/reference/index/type-aliases/seededgameboarddensityvalue/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:92](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L92)

Harbor or dock density.

***

### landmarks?

[Section titled “landmarks?”](#landmarks)

> `optional` **landmarks?**: [`SeededGameboardDensityValue`](/declarative-hex-worlds/reference/index/type-aliases/seededgameboarddensityvalue/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:94](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L94)

Landmark structure density.

***

### props?

[Section titled “props?”](#props)

> `optional` **props?**: [`SeededGameboardDensityValue`](/declarative-hex-worlds/reference/index/type-aliases/seededgameboarddensityvalue/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:90](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L90)

Prop scatter density.

***

### rocks?

[Section titled “rocks?”](#rocks)

> `optional` **rocks?**: [`SeededGameboardDensityValue`](/declarative-hex-worlds/reference/index/type-aliases/seededgameboarddensityvalue/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L88)

Rock scatter density.

***

### trees?

[Section titled “trees?”](#trees)

> `optional` **trees?**: [`SeededGameboardDensityValue`](/declarative-hex-worlds/reference/index/type-aliases/seededgameboarddensityvalue/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L86)

Tree scatter density.

***

### units?

[Section titled “units?”](#units)

> `optional` **units?**: [`SeededGameboardDensityValue`](/declarative-hex-worlds/reference/index/type-aliases/seededgameboarddensityvalue/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:96](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L96)

Unit placement density.

# SeededGameboardOptions

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:167](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L167)

High-level options for generating a playable seeded medieval gameboard.

## Extends

[Section titled “Extends”](#extends)

* `Partial`<[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/)>

## Properties

[Section titled “Properties”](#properties)

### defaultTerrain?

[Section titled “defaultTerrain?”](#defaultterrain)

> `optional` **defaultTerrain?**: `"grass"` | `"water"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:119](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L119)

Initial terrain used for every generated tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/).[`defaultTerrain`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/#defaultterrain)

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:171](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L171)

Primary faction used for settlements, harbors, and generated units.

***

### forestTiles?

[Section titled “forestTiles?”](#foresttiles)

> `optional` **forestTiles?**: `number`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:177](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L177)

Number of forest tiles to place.

***

### harborKind?

[Section titled “harborKind?”](#harborkind)

> `optional` **harborKind?**: [`HarborKind`](/declarative-hex-worlds/reference/index/type-aliases/harborkind/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:173](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L173)

Harbor composition variant to place on the coast.

***

### hillTiles?

[Section titled “hillTiles?”](#hilltiles)

> `optional` **hillTiles?**: `number`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:179](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L179)

Number of hill tiles to place.

***

### layoutArchetypes?

[Section titled “layoutArchetypes?”](#layoutarchetypes)

> `optional` **layoutArchetypes?**: `Readonly`<`Record`<`string`, [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)>>

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:187](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L187)

Additional archetypes available to generated layout fill rules.

***

### layoutDensity?

[Section titled “layoutDensity?”](#layoutdensity)

> `optional` **layoutDensity?**: [`SeededGameboardLayoutDensityOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardlayoutdensityoptions/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:185](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L185)

Built-in density preset overrides for layout fill.

***

### layoutFills?

[Section titled “layoutFills?”](#layoutfills)

> `optional` **layoutFills?**: readonly [`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:191](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L191)

Additional layout fill rules to run after built-in density and piece rules.

***

### layoutFillSeed?

[Section titled “layoutFillSeed?”](#layoutfillseed)

> `optional` **layoutFillSeed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:189](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L189)

Seed used for the layout fill pass.

***

### mountainStacks?

[Section titled “mountainStacks?”](#mountainstacks)

> `optional` **mountainStacks?**: `number`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:175](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L175)

Number of mountain stacks to place.

***

### pieceFills?

[Section titled “pieceFills?”](#piecefills)

> `optional` **pieceFills?**: readonly [`SeededGameboardPieceFillOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefilloptions/)\[]

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:195](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L195)

Piece fill rules that spawn registered external or custom pieces.

***

### pieceRegistry?

[Section titled “pieceRegistry?”](#pieceregistry)

> `optional` **pieceRegistry?**: [`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:193](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L193)

Piece registry used by seeded piece fill rules.

***

### scatterProps?

[Section titled “scatterProps?”](#scatterprops)

> `optional` **scatterProps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:183](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L183)

Number of loose prop decorations to scatter.

***

### seed?

[Section titled “seed?”](#seed)

> `optional` **seed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:113](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L113)

Deterministic seed for generation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/).[`seed`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/#seed)

***

### settlements?

[Section titled “settlements?”](#settlements)

> `optional` **settlements?**: `number`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:181](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L181)

Number of faction settlements to place.

***

### shape?

[Section titled “shape?”](#shape)

> `optional` **shape?**: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:169](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L169)

Board shape to generate.

#### Overrides

[Section titled “Overrides”](#overrides)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/).[`shape`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/#shape)

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:117](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L117)

Texture set applied to generated terrain.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/).[`textureSet`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/#textureset)

# SeededGameboardPieceFillInspection

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:145](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L145)

Full dry-run result for seeded piece fills against a plan.

## Properties

[Section titled “Properties”](#properties)

### analysis

[Section titled “analysis”](#analysis)

> **analysis**: [`GameboardLayoutFillAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillanalysis/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:155](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L155)

Eligibility and scoring analysis for the generated rules.

***

### errors

[Section titled “errors”](#errors)

> **errors**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:163](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L163)

Flattened fatal errors.

***

### placements

[Section titled “placements”](#placements)

> **placements**: readonly [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:157](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L157)

Deterministic placements that would be spawned.

***

### rules

[Section titled “rules”](#rules)

> **rules**: readonly [`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:153](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L153)

Fill rules generated from the selections.

***

### seed

[Section titled “seed”](#seed)

> **seed**: `string`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:147](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L147)

Seed used for the inspection.

***

### selectedPieceCount

[Section titled “selectedPieceCount”](#selectedpiececount)

> **selectedPieceCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:151](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L151)

Number of unique piece ids selected across all fills.

***

### selectionCount

[Section titled “selectionCount”](#selectioncount)

> **selectionCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:149](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L149)

Number of fill selections inspected.

***

### selections

[Section titled “selections”](#selections)

> **selections**: readonly [`SeededGameboardPieceFillSelectionInspection`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefillselectioninspection/)\[]

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:159](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L159)

Per-selection inspection details.

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:161](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L161)

Flattened non-fatal warnings.

# SeededGameboardPieceFillOptions

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:109](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L109)

Options for generating layout fill rules from a registered piece selection.

## Extends

[Section titled “Extends”](#extends)

* `Omit`<[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/), `"assetId"`>

## Properties

[Section titled “Properties”](#properties)

### archetypes?

[Section titled “archetypes?”](#archetypes)

> `optional` **archetypes?**: `Readonly`<`Record`<`string`, [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:261](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L261)

Archetype registry used by layout.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`archetypes`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#archetypes)

***

### count?

[Section titled “count?”](#count)

> `optional` **count?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:243](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L243)

Explicit placement count.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`count`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#count)

***

### criteria?

[Section titled “criteria?”](#criteria)

> `optional` **criteria?**: [`GameboardLayoutCriteria`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutcriteria/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:253](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L253)

Criteria merged over piece defaults.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`criteria`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#criteria)

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:259](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L259)

Vertical offset override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`elevationOffset`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#elevationoffset)

***

### fill?

[Section titled “fill?”](#fill)

> `optional` **fill?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:245](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L245)

Fraction of candidate sites to fill.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`fill`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#fill)

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:239](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L239)

Fill rule id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`id`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#id)

***

### idPrefix?

[Section titled “idPrefix?”](#idprefix)

> `optional` **idPrefix?**: `string`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:251](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L251)

Prefix used for generated placement ids.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`idPrefix`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#idprefix)

***

### maxCount?

[Section titled “maxCount?”](#maxcount)

> `optional` **maxCount?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:249](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L249)

Maximum placement count.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`maxCount`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#maxcount)

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:267](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L267)

Metadata merged over piece metadata.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`metadata`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#metadata)

***

### minCount?

[Section titled “minCount?”](#mincount)

> `optional` **minCount?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:247](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L247)

Minimum placement count.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`minCount`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#mincount)

***

### mode?

[Section titled “mode?”](#mode)

> `optional` **mode?**: [`SeededGameboardPieceFillMode`](/declarative-hex-worlds/reference/index/type-aliases/seededgameboardpiecefillmode/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:113](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L113)

Whether to create one rule per piece or a single pooled rule.

***

### occupancyGuard?

[Section titled “occupancyGuard?”](#occupancyguard)

> `optional` **occupancyGuard?**: [`GameboardPlacementOccupancyGuard`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementoccupancyguard/)

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:265](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L265)

Optional occupancy guard for spawned placements.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`occupancyGuard`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#occupancyguard)

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:263](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L263)

Local-only asset override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`requiresExtra`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#requiresextra)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number` | `"random"`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:257](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L257)

Rotation override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#rotationsteps)

***

### ruleIdPrefix?

[Section titled “ruleIdPrefix?”](#ruleidprefix)

> `optional` **ruleIdPrefix?**: `string`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:115](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L115)

Prefix used when generated per-piece rules need ids.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:255](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L255)

Uniform render scale override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`GameboardPieceLayoutRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecelayoutruleoptions/#scale)

***

### selection?

[Section titled “selection?”](#selection)

> `optional` **selection?**: [`GameboardPieceRegistrySelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryselection/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:111](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L111)

Registry selection used to choose pieces for the fill.

# SeededGameboardPieceFillSelectionInspection

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:119](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L119)

Inspection result for one piece-fill selection.

## Properties

[Section titled “Properties”](#properties)

### errors

[Section titled “errors”](#errors)

> **errors**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:135](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L135)

Fatal selection errors.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:121](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L121)

Fill id or generated inspection id.

***

### mode

[Section titled “mode”](#mode)

> **mode**: [`SeededGameboardPieceFillMode`](/declarative-hex-worlds/reference/index/type-aliases/seededgameboardpiecefillmode/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:123](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L123)

Fill mode used for the selection.

***

### selectedAssetIds

[Section titled “selectedAssetIds”](#selectedassetids)

> **selectedAssetIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:131](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L131)

Matched asset ids.

***

### selectedCount

[Section titled “selectedCount”](#selectedcount)

> **selectedCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:127](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L127)

Number of pieces matched by the selection.

***

### selectedPieceIds

[Section titled “selectedPieceIds”](#selectedpieceids)

> **selectedPieceIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:129](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L129)

Matched piece declaration ids.

***

### selection

[Section titled “selection”](#selection)

> **selection**: [`GameboardPieceRegistrySelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryselection/)

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:125](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L125)

Selection criteria that were inspected.

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:133](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L133)

Non-fatal selection warnings.

# SetGameboardMovementAgentOptions

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:93](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L93)

Options for registering or updating a movement agent.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/)

## Properties

[Section titled “Properties”](#properties)

### ignorePlacementIds?

[Section titled “ignorePlacementIds?”](#ignoreplacementids)

> `optional` **ignorePlacementIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:85](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L85)

Placement ids ignored during pathing.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/).[`ignorePlacementIds`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/#ignoreplacementids)

***

### movementBudget?

[Section titled “movementBudget?”](#movementbudget)

> `optional` **movementBudget?**: `number`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:83](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L83)

Movement budget override.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/).[`movementBudget`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/#movementbudget)

***

### navigation?

[Section titled “navigation?”](#navigation)

> `optional` **navigation?**: [`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:87](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L87)

Navigation profile overrides merged over the movement profile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/).[`navigation`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/#navigation)

***

### profile?

[Section titled “profile?”](#profile)

> `optional` **profile?**: [`GameboardMovementProfileInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardmovementprofileinput/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:79](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L79)

Movement profile id or inline profile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/).[`profile`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/#profile)

***

### profiles?

[Section titled “profiles?”](#profiles)

> `optional` **profiles?**: [`GameboardMovementProfileRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementprofileregistry/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:81](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L81)

Registry used to resolve profile ids.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/).[`profiles`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/#profiles)

***

### remainingMovement?

[Section titled “remainingMovement?”](#remainingmovement)

> `optional` **remainingMovement?**: `number`

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:95](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L95)

Remaining movement override. Defaults to full budget.

# SetGameboardPatrolAgentOptions

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:55](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L55)

Options for attaching a patrol agent to a placement or actor.

## Properties

[Section titled “Properties”](#properties)

### active?

[Section titled “active?”](#active)

> `optional` **active?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:63](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L63)

Whether the patrol starts active.

***

### alignToCurrentTile?

[Section titled “alignToCurrentTile?”](#aligntocurrenttile)

> `optional` **alignToCurrentTile?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:61](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L61)

Align starting waypoint to the placement’s current tile when possible.

***

### currentWaypointIndex?

[Section titled “currentWaypointIndex?”](#currentwaypointindex)

> `optional` **currentWaypointIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:59](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L59)

Starting waypoint index.

***

### movement?

[Section titled “movement?”](#movement)

> `optional` **movement?**: [`GameboardMovementPathRequestOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementpathrequestoptions/)

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L67)

Movement options used when requesting segment movement.

***

### pauseTicks?

[Section titled “pauseTicks?”](#pauseticks)

> `optional` **pauseTicks?**: `number`

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L65)

Ticks to wait after reaching each waypoint.

***

### route

[Section titled “route”](#route)

> **route**: `GameboardPatrolRoutePlan` | [`GameboardPatrolRouteInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolrouteinput/)

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:57](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L57)

Route plan or route input to follow.

# SettlementOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:406](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L406)

Options for adding a faction settlement building.

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:408](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L408)

Tile where the settlement is anchored.

***

### building

[Section titled “building”](#building)

> **building**: `"archeryrange"` | `"barracks"` | `"blacksmith"` | `"castle"` | `"church"` | `"docks"` | `"home_A"` | `"home_B"` | `"lumbermill"` | `"market"` | `"mine"` | `"shipyard"` | `"shrine"` | `"stables"` | `"tavern"` | `"tent"` | `"townhall"` | `"tower_A"` | `"tower_B"` | `"tower_base"` | `"tower_cannon"` | `"tower_catapult"` | `"watchtower"` | `"watermill"` | `"well"` | `"windmill"` | `"workshop"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:412](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L412)

Settlement building kind.

***

### faction

[Section titled “faction”](#faction)

> **faction**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:410](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L410)

Faction color for the building.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:414](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L414)

Clockwise 60-degree rotation steps.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:416](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L416)

Uniform render scale.

# SiegeProjectileOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:528](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L528)

Options for adding neutral siege projectile assets with gameplay metadata.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`AddSiegeProjectileRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addsiegeprojectilerecipestep/)

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:530](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L530)

Tile where the projectile is anchored.

***

### facing?

[Section titled “facing?”](#facing)

> `optional` **facing?**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:534](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L534)

Edge the projectile travels or points toward; also used as the default rotation.

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: `"catapult"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:532](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L532)

Projectile visual kind. Defaults to `catapult`.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:536](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L536)

Clockwise 60-degree rotation steps. Overrides `facing` when provided.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:540](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L540)

Uniform render scale.

***

### sourceId?

[Section titled “sourceId?”](#sourceid)

> `optional` **sourceId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:538](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L538)

Optional source actor, structure, or attack id.

# SpawnCoordinateOptions

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:53](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L53)

Options for deterministic spawn coordinate selection.

## Properties

[Section titled “Properties”](#properties)

### candidates?

[Section titled “candidates?”](#candidates)

> `optional` **candidates?**: readonly [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:61](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L61)

Explicit candidate coordinates to choose from.

***

### count

[Section titled “count”](#count)

> **count**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:57](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L57)

Number of coordinates to select.

***

### edgePadding?

[Section titled “edgePadding?”](#edgepadding)

> `optional` **edgePadding?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L67)

Number of outer rows/rings to avoid.

***

### minDistance?

[Section titled “minDistance?”](#mindistance)

> `optional` **minDistance?**: `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L65)

Minimum axial distance between selected coordinates.

***

### passable?

[Section titled “passable?”](#passable)

> `optional` **passable?**: (`coordinates`) => `boolean`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:63](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L63)

Predicate for rejecting blocked coordinates.

#### Parameters

[Section titled “Parameters”](#parameters)

##### coordinates

[Section titled “coordinates”](#coordinates)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

#### Returns

[Section titled “Returns”](#returns)

`boolean`

***

### seed?

[Section titled “seed?”](#seed)

> `optional` **seed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:59](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L59)

Seed used to shuffle candidates deterministically.

***

### shape

[Section titled “shape”](#shape)

> **shape**: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:55](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L55)

Board shape that bounds spawn selection.

# SpawnGameboardActorOptions

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:100](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L100)

Options for spawning a placement and registering it as an actor in one call.

## Extends

[Section titled “Extends”](#extends)

* [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/)

## Extended by

[Section titled “Extended by”](#extended-by)

* [`ResolvedGameboardScenarioActor`](/declarative-hex-worlds/reference/index/interfaces/resolvedgameboardscenarioactor/)

## Properties

[Section titled “Properties”](#properties)

### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:54](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L54)

Stable gameplay actor id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`actorId`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#actorid)

***

### actorKind?

[Section titled “actorKind?”](#actorkind)

> `optional` **actorKind?**: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:56](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L56)

Gameplay actor kind. Defaults from placement kind.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`actorKind`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#actorkind)

***

### actorMetadata?

[Section titled “actorMetadata?”](#actormetadata)

> `optional` **actorMetadata?**: `Readonly`<`Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:70](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L70)

Serializable actor metadata independent from placement metadata.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`actorMetadata`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#actormetadata)

***

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:302](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L302)

Manifest or external registry asset id to render.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`assetId`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#assetid)

***

### at

[Section titled “at”](#at)

> **at**: `string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:300](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L300)

Origin tile or tile key where the placement should spawn.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#at)

***

### blocksMovement?

[Section titled “blocksMovement?”](#blocksmovement)

> `optional` **blocksMovement?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:64](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L64)

Whether this actor blocks actor movement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`blocksMovement`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#blocksmovement)

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:310](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L310)

Extra vertical offset above the tile elevation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`elevationOffset`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#elevationoffset)

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `string` | `null`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L58)

Optional faction identifier.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`faction`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#faction)

***

### hostile?

[Section titled “hostile?”](#hostile)

> `optional` **hostile?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:62](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L62)

Whether this actor is generally hostile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`hostile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#hostile)

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:298](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L298)

Explicit placement id. Defaults to a deterministic runtime id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`id`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#id)

***

### interactive?

[Section titled “interactive?”](#interactive)

> `optional` **interactive?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:66](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L66)

Whether this actor should be considered an interaction target.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`interactive`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#interactive)

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:304](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L304)

Gameplay category for rules, selectors, and rendering.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`kind`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#kind)

***

### layer?

[Section titled “layer?”](#layer)

> `optional` **layer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:306](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L306)

Render and occupancy layer. Defaults from `kind`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`layer`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#layer)

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:324](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L324)

Serializable placement metadata for rules, ECS interop, and render hints.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`metadata`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#metadata)

***

### occupancyGuard?

[Section titled “occupancyGuard?”](#occupancyguard)

> `optional` **occupancyGuard?**: [`GameboardPlacementOccupancyGuard`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementoccupancyguard/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:326](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L326)

Optional occupancy validation before spawning.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-14)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`occupancyGuard`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#occupancyguard)

***

### order?

[Section titled “order?”](#order)

> `optional` **order?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:318](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L318)

Stable sort order used by renderers and snapshots.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-15)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`order`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#order)

***

### positionOffset?

[Section titled “positionOffset?”](#positionoffset)

> `optional` **positionOffset?**: [`GameboardPlacementPositionOffset`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementpositionoffset/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:312](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L312)

Local world-space offset after tile/elevation anchoring.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-16)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`positionOffset`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#positionoffset)

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:322](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L322)

Whether the placement depends on local-only EXTRA assets.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-17)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`requiresExtra`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#requiresextra)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:314](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L314)

Clockwise 60-degree rotation steps.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-18)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:316](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L316)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-19)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#scale)

***

### stackIndex?

[Section titled “stackIndex?”](#stackindex)

> `optional` **stackIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:320](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L320)

Optional stack index for layered terrain and vertical props.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-20)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`stackIndex`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#stackindex)

***

### tags?

[Section titled “tags?”](#tags)

> `optional` **tags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:68](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L68)

Free-form actor tags used by selectors and quests.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-21)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`tags`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#tags)

***

### team?

[Section titled “team?”](#team)

> `optional` **team?**: `string` | `null`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:60](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L60)

Optional team identifier. Defaults to faction when omitted.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-22)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/).[`team`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/#team)

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:308](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L308)

Texture set override. Defaults to the origin tile texture set.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-23)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/).[`textureSet`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/#textureset)

# SpawnGameboardPlacementOptions

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:296](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L296)

Options for spawning a runtime placement into an existing gameboard world.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/)

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:302](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L302)

Manifest or external registry asset id to render.

***

### at

[Section titled “at”](#at)

> **at**: `string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:300](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L300)

Origin tile or tile key where the placement should spawn.

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:310](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L310)

Extra vertical offset above the tile elevation.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:298](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L298)

Explicit placement id. Defaults to a deterministic runtime id.

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:304](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L304)

Gameplay category for rules, selectors, and rendering.

***

### layer?

[Section titled “layer?”](#layer)

> `optional` **layer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:306](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L306)

Render and occupancy layer. Defaults from `kind`.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:324](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L324)

Serializable placement metadata for rules, ECS interop, and render hints.

***

### occupancyGuard?

[Section titled “occupancyGuard?”](#occupancyguard)

> `optional` **occupancyGuard?**: [`GameboardPlacementOccupancyGuard`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementoccupancyguard/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:326](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L326)

Optional occupancy validation before spawning.

***

### order?

[Section titled “order?”](#order)

> `optional` **order?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:318](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L318)

Stable sort order used by renderers and snapshots.

***

### positionOffset?

[Section titled “positionOffset?”](#positionoffset)

> `optional` **positionOffset?**: [`GameboardPlacementPositionOffset`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementpositionoffset/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:312](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L312)

Local world-space offset after tile/elevation anchoring.

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:322](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L322)

Whether the placement depends on local-only EXTRA assets.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:314](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L314)

Clockwise 60-degree rotation steps.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:316](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L316)

Uniform render scale.

***

### stackIndex?

[Section titled “stackIndex?”](#stackindex)

> `optional` **stackIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:320](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L320)

Optional stack index for layered terrain and vertical props.

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:308](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L308)

Texture set override. Defaults to the origin tile texture set.

# SpawnGameboardQuestOptions

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:94](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L94)

Options for spawning a quest.

## Properties

[Section titled “Properties”](#properties)

### status?

[Section titled “status?”](#status)

> `optional` **status?**: [`GameboardQuestStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardqueststatus/)

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:96](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L96)

Initial quest status. Defaults to `active`.

# SummarizeGameboardPlanOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:273](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L273)

Options for summarizing a generated or projected gameboard plan.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`SummarizeGameboardScenarioOptions`](/declarative-hex-worlds/reference/index/interfaces/summarizegameboardscenariooptions/)

## Properties

[Section titled “Properties”](#properties)

### topAssetLimit?

[Section titled “topAssetLimit?”](#topassetlimit)

> `optional` **topAssetLimit?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:279](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L279)

Maximum number of high-frequency assets to include in `topAssets`.

Defaults to 20. Use `0` when only aggregate counts are needed.

# SummarizeGameboardScenarioOptions

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:178](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L178)

Options for summarizing an authored scenario and its compiled board.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardScenarioValidationConfig`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariovalidationconfig/).[`SummarizeGameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/summarizegameboardplanoptions/)

## Properties

[Section titled “Properties”](#properties)

### plan?

[Section titled “plan?”](#plan)

> `optional` **plan?**: [`GameboardPlanValidationConfig`](/declarative-hex-worlds/reference/rules/validation/interfaces/gameboardplanvalidationconfig/)

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:158](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L158)

Validation config passed to compiled plan validation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardScenarioValidationConfig`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariovalidationconfig/).[`plan`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariovalidationconfig/#plan)

***

### topAssetLimit?

[Section titled “topAssetLimit?”](#topassetlimit)

> `optional` **topAssetLimit?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:279](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L279)

Maximum number of high-frequency assets to include in `topAssets`.

Defaults to 20. Use `0` when only aggregate counts are needed.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`SummarizeGameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/summarizegameboardplanoptions/).[`topAssetLimit`](/declarative-hex-worlds/reference/index/interfaces/summarizegameboardplanoptions/#topassetlimit)

***

### validatePlan?

[Section titled “validatePlan?”](#validateplan)

> `optional` **validatePlan?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:160](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L160)

Whether to validate the compiled plan in addition to scenario references.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardScenarioValidationConfig`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariovalidationconfig/).[`validatePlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariovalidationconfig/#validateplan)

# TextureBinding

Defined in: [packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts:15](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts#L15)

A texture bound to a model, optionally scoped to specific meshes/materials by name.

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> `readonly` **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts:17](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts#L17)

Asset id of the model these textures apply to.

***

### normalUrl?

[Section titled “normalUrl?”](#normalurl)

> `readonly` `optional` **normalUrl?**: `string`

Defined in: [packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts:26](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts#L26)

Optional normal-map URL applied alongside the base-color map.

***

### targets?

[Section titled “targets?”](#targets)

> `readonly` `optional` **targets?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts:24](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts#L24)

Names of the meshes/materials the texture applies to. When omitted, the texture is applied to EVERY mesh material in the model.

***

### textureUrl

[Section titled “textureUrl”](#textureurl)

> `readonly` **textureUrl**: `string`

Defined in: [packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts:19](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts#L19)

URL of the texture to apply as the base-color map.

# TileAssetOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:650](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L650)

Options for overriding the base tile asset and guide connectivity state.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`SetTileAssetRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/settileassetrecipestep/)

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:654](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L654)

Base tile asset id.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:652](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L652)

Tile whose asset state should be replaced.

***

### coastEdges?

[Section titled “coastEdges?”](#coastedges)

> `optional` **coastEdges?**: [`HexEdgeInput`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeinput/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:666](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L666)

Replacement coast edge input.

***

### coastWaterless?

[Section titled “coastWaterless?”](#coastwaterless)

> `optional` **coastWaterless?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:676](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L676)

Whether the coast uses a waterless variant.

***

### elevation?

[Section titled “elevation?”](#elevation)

> `optional` **elevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:660](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L660)

Replacement elevation.

***

### riverCrossing?

[Section titled “riverCrossing?”](#rivercrossing)

> `optional` **riverCrossing?**: [`RiverCrossing`](/declarative-hex-worlds/reference/index/type-aliases/rivercrossing/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:674](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L674)

River crossing variant.

***

### riverCurvy?

[Section titled “riverCurvy?”](#rivercurvy)

> `optional` **riverCurvy?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:672](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L672)

Whether the river uses a curvy variant.

***

### riverEdges?

[Section titled “riverEdges?”](#riveredges)

> `optional` **riverEdges?**: [`HexEdgeInput`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeinput/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:664](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L664)

Replacement river edge input.

***

### riverWaterless?

[Section titled “riverWaterless?”](#riverwaterless)

> `optional` **riverWaterless?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:670](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L670)

Whether the river uses a waterless variant.

***

### roadEdges?

[Section titled “roadEdges?”](#roadedges)

> `optional` **roadEdges?**: [`HexEdgeInput`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeinput/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:662](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L662)

Replacement road edge input.

***

### roadSlope?

[Section titled “roadSlope?”](#roadslope)

> `optional` **roadSlope?**: [`RoadSlope`](/declarative-hex-worlds/reference/index/type-aliases/roadslope/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:668](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L668)

Road slope variant.

***

### supportAssetId?

[Section titled “supportAssetId?”](#supportassetid)

> `optional` **supportAssetId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:658](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L658)

Replacement support/bottom asset id.

***

### tags?

[Section titled “tags?”](#tags)

> `optional` **tags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:680](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L680)

Additional tile tags.

***

### terrain?

[Section titled “terrain?”](#terrain)

> `optional` **terrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:656](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L656)

Replacement terrain category.

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:678](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L678)

Replacement texture set for this tile.

# TilesetSourceOptions

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset.ts:90](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset.ts#L90)

Options for a tileset source.

## Properties

[Section titled “Properties”](#properties)

### hex?

[Section titled “hex?”](#hex)

> `optional` **hex?**: [`HexDims`](/declarative-hex-worlds/reference/index/interfaces/hexdims/)

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset.ts:98](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset.ts#L98)

The rendered cell’s world-space footprint. Defaults to the board’s default hex footprint (`DEFAULT_TILESET_HEX`), which tessellates seamlessly with the default `'quad'` render shape. Override for a non-standard board geometry.

***

### manifest

[Section titled “manifest”](#manifest)

> **manifest**: `object`

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset.ts:92](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset.ts#L92)

The validated tileset manifest to resolve against.

#### biomes

[Section titled “biomes”](#biomes)

> **biomes**: `Record`<`string`, { `select`: `"first"` | `"hash"`; `sheet`: `string`; }>

#### kind

[Section titled “kind”](#kind)

> **kind**: `"tileset"`

#### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> **schemaVersion**: `string`

#### sheets

[Section titled “sheets”](#sheets)

> **sheets**: `Record`<`string`, { `edgeCells?`: `Record`<`string`, `number`>; `grid`: { `cellHeight`: `number`; `cellWidth`: `number`; `cols`: `number`; `rows`: `number`; }; `role`: `"transition"` | `"fill"`; `url`: `string`; `variants?`: `number`\[]; }>

***

### shape?

[Section titled “shape?”](#shape)

> `optional` **shape?**: `"hex"` | `"quad"`

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset.ts:104](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset.ts#L104)

How each cell is drawn (see `AssetRenderRequest['shape']`). Defaults to `'quad'` — the seamless path for painterly hex atlases whose cells have transparent corners. Use `'hex'` only for sheets whose cells are opaque edge-to-edge.

# TransitionPlacementOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:598](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L598)

Options for adding an EXTRA texture transition placement.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`AddTransitionRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addtransitionrecipestep/)

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:600](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L600)

Tile where the transition is anchored.

***

### from

[Section titled “from”](#from)

> **from**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:602](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L602)

Source texture set.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:606](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L606)

Clockwise 60-degree rotation steps.

***

### to

[Section titled “to”](#to)

> **to**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:604](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L604)

Destination texture set.

# UnitPlacementOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:612](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L612)

Options for adding one EXTRA unit part.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`AddUnitRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addunitrecipestep/)

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:614](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L614)

Tile where the unit part is anchored.

***

### compositeId?

[Section titled “compositeId?”](#compositeid)

> `optional` **compositeId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:624](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L624)

Shared composite id for multi-part units.

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:618](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L618)

Faction used by colored unit parts.

***

### neutral?

[Section titled “neutral?”](#neutral)

> `optional` **neutral?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:622](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L622)

Force neutral unit asset selection.

***

### part

[Section titled “part”](#part)

> **part**: `"banner"` | `"bow"` | `"cannon"` | `"cart"` | `"cart_merchant"` | `"catapult"` | `"helmet"` | `"horse"` | `"projectile_arrow"` | `"shield"` | `"ship"` | `"spear"` | `"sword"` | `"unit"` | `"hammer"` | `"horse_A"` | `"horse_B"` | `"horse_C"` | `"horse_D"` | `"horse_E"` | `"horse_F"` | `"horse_G"` | `"horse_saddle"` | `"projectile_cannonball"` | `"projectile_catapult"` | `"shovel"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:616](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L616)

Unit part asset id.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:626](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L626)

Clockwise 60-degree rotation steps.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:628](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L628)

Uniform render scale.

***

### style?

[Section titled “style?”](#style)

> `optional` **style?**: `"accent"` | `"full"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:620](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L620)

Colored unit style.

# UnitPresetOptions

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:634](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L634)

Options for adding a predefined multi-part unit composition.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`AddUnitPresetRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addunitpresetrecipestep/)

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:636](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L636)

Tile where the unit preset is anchored.

***

### faction

[Section titled “faction”](#faction)

> **faction**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:638](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L638)

Faction used by colored unit parts.

***

### role

[Section titled “role”](#role)

> **role**: `"ship"` | `"worker"` | `"soldier"` | `"archer"` | `"cavalry"` | `"merchant"` | `"siege"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:642](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L642)

Unit role composition to create.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:644](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L644)

Clockwise 60-degree rotation steps.

***

### style?

[Section titled “style?”](#style)

> `optional` **style?**: `"accent"` | `"full"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:640](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L640)

Colored unit style.

# UpdateGameboardActorOptions

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:76](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L76)

Options for updating gameplay actor state while preserving omitted fields.

## Properties

[Section titled “Properties”](#properties)

### actorId?

[Section titled “actorId?”](#actorid)

> `optional` **actorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:78](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L78)

Replacement gameplay actor id.

***

### actorKind?

[Section titled “actorKind?”](#actorkind)

> `optional` **actorKind?**: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/)

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:80](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L80)

Replacement gameplay actor kind.

***

### actorMetadata?

[Section titled “actorMetadata?”](#actormetadata)

> `optional` **actorMetadata?**: `Readonly`<`Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:94](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L94)

Replacement serializable actor metadata.

***

### blocksMovement?

[Section titled “blocksMovement?”](#blocksmovement)

> `optional` **blocksMovement?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L88)

Replacement movement-blocking flag.

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `string` | `null`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:82](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L82)

Replacement faction identifier.

***

### hostile?

[Section titled “hostile?”](#hostile)

> `optional` **hostile?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L86)

Replacement hostility flag.

***

### interactive?

[Section titled “interactive?”](#interactive)

> `optional` **interactive?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:90](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L90)

Replacement interaction-target flag.

***

### tags?

[Section titled “tags?”](#tags)

> `optional` **tags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:92](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L92)

Replacement actor tags.

***

### team?

[Section titled “team?”](#team)

> `optional` **team?**: `string` | `null`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:84](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L84)

Replacement team identifier.

# UpdateGameboardPlacementOptions

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:332](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L332)

Options for mutating an existing runtime placement.

## Properties

[Section titled “Properties”](#properties)

### assetId?

[Section titled “assetId?”](#assetid)

> `optional` **assetId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:336](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L336)

New manifest or external registry asset id.

***

### at?

[Section titled “at?”](#at)

> `optional` **at?**: `string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:334](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L334)

New origin tile or tile key.

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:344](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L344)

New vertical offset above the tile elevation.

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:338](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L338)

New gameplay category.

***

### layer?

[Section titled “layer?”](#layer)

> `optional` **layer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:340](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L340)

New render and occupancy layer.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:358](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L358)

Replacement serializable placement metadata.

***

### occupancyGuard?

[Section titled “occupancyGuard?”](#occupancyguard)

> `optional` **occupancyGuard?**: [`GameboardPlacementOccupancyGuard`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementoccupancyguard/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:360](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L360)

Optional occupancy validation before applying the mutation.

***

### order?

[Section titled “order?”](#order)

> `optional` **order?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:352](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L352)

New stable sort order.

***

### positionOffset?

[Section titled “positionOffset?”](#positionoffset)

> `optional` **positionOffset?**: [`GameboardPlacementPositionOffset`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementpositionoffset/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:346](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L346)

New local world-space offset after tile/elevation anchoring.

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:356](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L356)

New local-only EXTRA requirement flag.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:348](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L348)

New clockwise 60-degree rotation steps.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:350](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L350)

New uniform render scale.

***

### stackIndex?

[Section titled “stackIndex?”](#stackindex)

> `optional` **stackIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:354](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L354)

New stack index.

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:342](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L342)

New texture set.

# AssetDimension

> **AssetDimension** = `"2d"` | `"3d"`

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:30](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L30)

The dimensionality of a rendered asset — a first-class concept so a backend (three for 3D/2.5D, a future Pixi backend for 2D) knows how to place, sort, and orient it. A `'3d'` asset is a volumetric mesh; a `'2d'` asset is a planar sprite whose depth is a z-order, not a world Y. `<Model>` is 3D-first, `<Sprite>` 2D-first, and both can coexist on one board (2.5D).

# AssetFormat

> **AssetFormat** = *typeof* [`ASSET_FORMATS`](/declarative-hex-worlds/reference/index/variables/asset_formats/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/asset-source/spec.ts:28](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/spec.ts#L28)

# AssetGrid

> **AssetGrid** = `z.infer`<*typeof* `gridSchema`>

Defined in: [packages/declarative-hex-worlds/src/asset-source/spec.ts:57](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/spec.ts#L57)

# AssetRenderRequest

> **AssetRenderRequest** = { `dimension`: `"3d"`; `opacity?`: `number`; `tint?`: [`AssetTint`](/declarative-hex-worlds/reference/index/interfaces/assettint/); `transform?`: [`AssetTransform`](/declarative-hex-worlds/reference/index/interfaces/assettransform/); `type`: `"gltf"`; `url`: `string`; } | { `cell`: [`CellRect`](/declarative-hex-worlds/reference/index/interfaces/cellrect/); `dimension`: `"2d"`; `hex`: [`HexDims`](/declarative-hex-worlds/reference/index/interfaces/hexdims/); `opacity?`: `number`; `shape?`: `"quad"` | `"hex"`; `sheetUrl`: `string`; `tint?`: [`AssetTint`](/declarative-hex-worlds/reference/index/interfaces/assettint/); `transform?`: [`AssetTransform`](/declarative-hex-worlds/reference/index/interfaces/assettransform/); `type`: `"tileset-cell"`; }

Defined in: [packages/declarative-hex-worlds/src/asset-source/source.ts:96](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/source.ts#L96)

A resolved, renderer-agnostic render request. A renderer BINDING (the `declarative-hex-worlds/three` subpath today, `/pixi` tomorrow) subscribes to the koota placement signals and dispatches on `type` + `dimension` to reconcile its own scene nodes. New source kinds add new members here (a discriminated union), and each binding grows a matching arm. Every request carries its `dimension` so a binding can place/sort/orient a 2D sprite and a 3D model correctly on the same board.

## Union Members

[Section titled “Union Members”](#union-members)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `dimension`: `"3d"`; `opacity?`: `number`; `tint?`: [`AssetTint`](/declarative-hex-worlds/reference/index/interfaces/assettint/); `transform?`: [`AssetTransform`](/declarative-hex-worlds/reference/index/interfaces/assettransform/); `type`: `"gltf"`; `url`: `string`; }

#### dimension

[Section titled “dimension”](#dimension)

> **dimension**: `"3d"`

#### opacity?

[Section titled “opacity?”](#opacity)

> `optional` **opacity?**: `number`

Optional per-placement opacity in `[0, 1]`. `< 1` makes the placement translucent (e.g. a fog shroud over an explored tile); omitted or `>= 1` leaves it fully opaque.

#### tint?

[Section titled “tint?”](#tint)

> `optional` **tint?**: [`AssetTint`](/declarative-hex-worlds/reference/index/interfaces/assettint/)

Optional per-placement multiplicative tint (fog/season/team shading). White ⇒ identity. Applied by the binding to the resolved object’s material colour.

#### transform?

[Section titled “transform?”](#transform)

> `optional` **transform?**: [`AssetTransform`](/declarative-hex-worlds/reference/index/interfaces/assettransform/)

#### type

[Section titled “type”](#type)

> **type**: `"gltf"`

#### url

[Section titled “url”](#url)

> **url**: `string`

***

### Type Literal

[Section titled “Type Literal”](#type-literal-1)

{ `cell`: [`CellRect`](/declarative-hex-worlds/reference/index/interfaces/cellrect/); `dimension`: `"2d"`; `hex`: [`HexDims`](/declarative-hex-worlds/reference/index/interfaces/hexdims/); `opacity?`: `number`; `shape?`: `"quad"` | `"hex"`; `sheetUrl`: `string`; `tint?`: [`AssetTint`](/declarative-hex-worlds/reference/index/interfaces/assettint/); `transform?`: [`AssetTransform`](/declarative-hex-worlds/reference/index/interfaces/assettransform/); `type`: `"tileset-cell"`; }

#### cell

[Section titled “cell”](#cell)

> **cell**: [`CellRect`](/declarative-hex-worlds/reference/index/interfaces/cellrect/)

#### dimension

[Section titled “dimension”](#dimension-1)

> **dimension**: `"2d"`

#### hex

[Section titled “hex”](#hex)

> **hex**: [`HexDims`](/declarative-hex-worlds/reference/index/interfaces/hexdims/)

#### opacity?

[Section titled “opacity?”](#opacity-1)

> `optional` **opacity?**: `number`

Optional per-placement opacity in `[0, 1]`. `< 1` makes the cell translucent (e.g. a fog shroud over an explored tile); omitted or `>= 1` leaves the opaque-queue path (seamless cutout tessellation) unchanged.

#### shape?

[Section titled “shape?”](#shape)

> `optional` **shape?**: `"quad"` | `"hex"`

How the sheet cell is drawn onto the board plane:

* `'quad'` (default): the FULL cell rect is drawn as a rectangle spanning `hex.width × hex.height`. Painterly hex atlases (e.g. JackleEarth) paint each cell as a flattened hex with TRANSPARENT corners — a full quad lets neighbouring cells’ opaque bodies fill each other’s transparent corners, so the board tessellates SEAMLESSLY into continuous terrain. This is what the canvas-2D binding already does (`drawImage` blits the whole cell), so `'quad'` makes the 3D binding match.
* `'hex'`: the cell is clipped to a hexagon silhouette (UV-mapped to the cell). Use only for sheets whose cells are opaque edge-to-edge and must NOT bleed past the hex outline. Leaves gaps for transparent-corner art. Omitted ⇒ `'quad'`.

#### sheetUrl

[Section titled “sheetUrl”](#sheeturl)

> **sheetUrl**: `string`

#### tint?

[Section titled “tint?”](#tint-1)

> `optional` **tint?**: [`AssetTint`](/declarative-hex-worlds/reference/index/interfaces/assettint/)

Optional per-placement multiplicative tint (fog/season/team shading). White ⇒ identity. Multiplies the sampled cell colour, so one atlas serves every shading state without re-authoring art.

#### transform?

[Section titled “transform?”](#transform-1)

> `optional` **transform?**: [`AssetTransform`](/declarative-hex-worlds/reference/index/interfaces/assettransform/)

#### type

[Section titled “type”](#type-1)

> **type**: `"tileset-cell"`

# AssetRole

> **AssetRole** = *typeof* [`ASSET_ROLES`](/declarative-hex-worlds/reference/index/variables/asset_roles/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/asset-source/spec.ts:24](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/spec.ts#L24)

# AssetSourceSpec

> **AssetSourceSpec** = `z.infer`<*typeof* [`assetSourceSpecSchema`](/declarative-hex-worlds/reference/index/variables/assetsourcespecschema/)>

Defined in: [packages/declarative-hex-worlds/src/asset-source/spec.ts:155](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/spec.ts#L155)

# AssetSpec

> **AssetSpec** = `z.infer`<*typeof* [`assetSchema`](/declarative-hex-worlds/reference/index/variables/assetschema/)>

Defined in: [packages/declarative-hex-worlds/src/asset-source/spec.ts:125](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/spec.ts#L125)

# BridgeVariant

> **BridgeVariant** = `"A"` | `"B"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:73](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L73)

Neutral bridge visual variant.

# BuiltInGameboardTerrain

> **BuiltInGameboardTerrain** = `"grass"` | `"water"` | `"coast"` | `"road"` | `"river"` | `"mountain"` | `"hill"` | `"forest"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:34](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L34)

Built-in terrain categories understood by the guide-derived helpers.

# CameraAngle

> **CameraAngle** = `"top-down"` | `"isometric"` | `"tilted"`

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:28](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L28)

How the camera looks at the board.

# CameraFit

> **CameraFit** = `"frame-board"` | `"fill-viewport"`

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:40](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L40)

How the framing fits the board into the view.

# CameraProjection

> **CameraProjection** = `"orthographic"` | `"perspective"`

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:37](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L37)

Projection kind — orthographic (no perspective foreshortening) or perspective.

# ClassifierTag

> **ClassifierTag** = [`KnownClassifierTag`](/declarative-hex-worlds/reference/index/type-aliases/knownclassifiertag/) | `string` & `object`

Defined in: [packages/declarative-hex-worlds/src/classifiers/classifiers.ts:31](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/classifiers/classifiers.ts#L31)

A classifier tag — a known one or an app-specific custom string.

# ConstructionSiteKind

> **ConstructionSiteKind** = `"destroyed"` | `"dirt"` | `"grain"` | `"scaffolding"` | `"stage-A"` | `"stage-B"` | `"stage-C"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:92](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L92)

Construction and ruin state exposed by the neutral construction assets.

# CreateGameboardRuntimeInput

> **CreateGameboardRuntimeInput** = [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/) | `World` | [`CreateGameboardRuntimeOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardruntimeoptions/)

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:244](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L244)

Accepted input for creating a runtime facade.

# ElevationRampDirection

> **ElevationRampDirection** = `"up"` | `"down"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:75](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L75)

Sloped elevation ramp direction.

# FenceFortificationSegment

> **FenceFortificationSegment** = `"straight"` | `"gate"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L88)

Fence segment shape from the neutral fence asset set.

# FortificationMaterial

> **FortificationMaterial** = `"wall"` | `"wood-fence"` | `"stone-fence"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:77](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L77)

Fortification material exposed by the neutral wall and fence assets.

# FortificationSegment

> **FortificationSegment** = [`WallFortificationSegment`](/declarative-hex-worlds/reference/index/type-aliases/wallfortificationsegment/) | [`FenceFortificationSegment`](/declarative-hex-worlds/reference/index/type-aliases/fencefortificationsegment/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:90](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L90)

Segment shape accepted by fortification helpers.

# GameboardActionBundle

> **GameboardActionBundle** = `ReturnType`<*typeof* [`gameboardActions`](/declarative-hex-worlds/reference/index/variables/gameboardactions/)>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:209](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L209)

Koota action bundle for raw board placement operations.

# GameboardActorActionBundle

> **GameboardActorActionBundle** = `ReturnType`<*typeof* [`gameboardActorActions`](/declarative-hex-worlds/reference/index/variables/gameboardactoractions/)>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:214](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L214)

Koota action bundle for actor spawning, movement, and selection.

# GameboardActorSelectionSort

> **GameboardActorSelectionSort** = `"actorId"` | `"distance"` | `"tileKey"`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:373](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L373)

Sort modes for actor selection results.

# GameboardActorTargetApproach

> **GameboardActorTargetApproach** = `"target-tile"` | `"adjacent"` | `"nearest"`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:496](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L496)

Strategy used when pathing to a target actor.

# GameboardActorTargetSort

> **GameboardActorTargetSort** = `"pathCost"` | `"distance"` | `"actorId"` | `"tileKey"`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:500](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L500)

Sort modes for target reports.

# GameboardActorValue

> **GameboardActorValue** = `TraitRecord`<*typeof* [`GameboardActor`](/declarative-hex-worlds/reference/traits/variables/gameboardactor/)>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:683](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L683)

Actor trait value returned by `GameboardActor`.

# GameboardCommandActionBundle

> **GameboardCommandActionBundle** = `ReturnType`<*typeof* [`gameboardCommandActions`](/declarative-hex-worlds/reference/index/variables/gameboardcommandactions/)>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:234](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L234)

Koota action bundle for command planning, preview, execution, and targeting.

# GameboardEcsRelationName

> **GameboardEcsRelationName** = `"AdjacentTo"` | `"PlacementOnTile"` | `"PlacementOccupiesTile"` | `"SpawnOnTile"` | `"SpawnGroupHasLocation"` | `"SpawnGroupRouteCheck"` | `"PatrolRouteHasWaypoint"` | `"PatrolWaypointOnTile"` | `"PatrolRouteSegment"` | `"ActorOnTile"` | `"ActorPlacement"` | `"ActorPatrolRoute"` | `"QuestReferencesActor"` | `"QuestTargetsTile"` | `"SimulationHasStep"` | `"SimulationStepActorTargets"` | `"SimulationStepCommand"` | `"SimulationStepPatrol"` | `"SimulationStepMovement"` | `"SimulationStepMutation"` | `"CommandSourceActor"` | `"CommandTargetActor"` | `"ActorTargetsSourceActor"` | `"ActorTargetsTargetActor"` | `"CommandEffectActor"` | `"CommandEffectPlacement"` | `"PatrolActor"` | `"PatrolPlacement"` | `"MovementActor"` | `"MovementPlacement"` | `"MutationActor"` | `"MutationPlacement"`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:508](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L508)

Relation name emitted by interop snapshots.

# GameboardInteractionCommandInput

> **GameboardInteractionCommandInput** = [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/) | [`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:39](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L39)

Input accepted by command helpers: either an already planned command or a renderer/gameplay target that should be planned first.

# GameboardInteractionCommandKind

> **GameboardInteractionCommandKind** = `"move"` | `"interact-actor"` | `"interact-placement"` | `"attack-actor"` | `"inspect-actor"` | `"inspect-placement"` | `"inspect-tile"` | `"none"`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:184](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L184)

Concrete command kind produced from an interaction target.

# GameboardInteractionExecutionStatus

> **GameboardInteractionExecutionStatus** = `"handled"` | `"requested-move"` | `"requires-game-handler"` | `"blocked"` | `"ignored"`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:46](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L46)

Execution outcome for a planned interaction command.

# GameboardInteractionHandler

> **GameboardInteractionHandler** = (`context`) => [`GameboardInteractionHandlerResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractionhandlerresult/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:153](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L153)

Game-supplied handler for commands that require host-specific policy.

## Parameters

[Section titled “Parameters”](#parameters)

### context

[Section titled “context”](#context)

[`GameboardInteractionHandlerContext`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractionhandlercontext/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardInteractionHandlerResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractionhandlerresult/) | `undefined`

# GameboardInteractionHandlerEffect

> **GameboardInteractionHandlerEffect** = { `actorId`: `string`; `placementId?`: `string`; `reason?`: `string`; `removed`: `boolean`; `type`: `"actor-removed"`; } | { `placementId`: `string`; `reason?`: `string`; `removed`: `boolean`; `type`: `"placement-removed"`; } | { `actorId`: `string`; `placementId?`: `string`; `reason?`: `string`; `type`: `"actor-updated"`; `updated`: `boolean`; } | { `placementId`: `string`; `reason?`: `string`; `type`: `"placement-updated"`; `updated`: `boolean`; }

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:69](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L69)

Serializable side effect emitted by a command handler.

## Union Members

[Section titled “Union Members”](#union-members)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `actorId`: `string`; `placementId?`: `string`; `reason?`: `string`; `removed`: `boolean`; `type`: `"actor-removed"`; }

#### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string`

Actor id that the handler attempted to remove.

#### placementId?

[Section titled “placementId?”](#placementid)

> `optional` **placementId?**: `string`

Placement id associated with the removed actor.

#### reason?

[Section titled “reason?”](#reason)

> `optional` **reason?**: `string`

Optional failure or diagnostic reason.

#### removed

[Section titled “removed”](#removed)

> **removed**: `boolean`

Whether the actor placement was removed.

#### type

[Section titled “type”](#type)

> **type**: `"actor-removed"`

Effect discriminator for removing an actor placement.

***

### Type Literal

[Section titled “Type Literal”](#type-literal-1)

{ `placementId`: `string`; `reason?`: `string`; `removed`: `boolean`; `type`: `"placement-removed"`; }

#### placementId

[Section titled “placementId”](#placementid-1)

> **placementId**: `string`

Placement id that the handler attempted to remove.

#### reason?

[Section titled “reason?”](#reason-1)

> `optional` **reason?**: `string`

Optional failure or diagnostic reason.

#### removed

[Section titled “removed”](#removed-1)

> **removed**: `boolean`

Whether the placement was removed.

#### type

[Section titled “type”](#type-1)

> **type**: `"placement-removed"`

Effect discriminator for removing a non-actor placement.

***

### Type Literal

[Section titled “Type Literal”](#type-literal-2)

{ `actorId`: `string`; `placementId?`: `string`; `reason?`: `string`; `type`: `"actor-updated"`; `updated`: `boolean`; }

#### actorId

[Section titled “actorId”](#actorid-1)

> **actorId**: `string`

Actor id that the handler attempted to update.

#### placementId?

[Section titled “placementId?”](#placementid-2)

> `optional` **placementId?**: `string`

Placement id associated with the actor.

#### reason?

[Section titled “reason?”](#reason-2)

> `optional` **reason?**: `string`

Optional failure or diagnostic reason.

#### type

[Section titled “type”](#type-2)

> **type**: `"actor-updated"`

Effect discriminator for actor metadata updates.

#### updated

[Section titled “updated”](#updated)

> **updated**: `boolean`

Whether actor state was updated.

***

### Type Literal

[Section titled “Type Literal”](#type-literal-3)

{ `placementId`: `string`; `reason?`: `string`; `type`: `"placement-updated"`; `updated`: `boolean`; }

#### placementId

[Section titled “placementId”](#placementid-3)

> **placementId**: `string`

Placement id that the handler attempted to update.

#### reason?

[Section titled “reason?”](#reason-3)

> `optional` **reason?**: `string`

Optional failure or diagnostic reason.

#### type

[Section titled “type”](#type-3)

> **type**: `"placement-updated"`

Effect discriminator for placement metadata updates.

#### updated

[Section titled “updated”](#updated-1)

> **updated**: `boolean`

Whether placement state was updated.

# GameboardInteractionHandlerMetadata

> **GameboardInteractionHandlerMetadata** = `Readonly`<`Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>>

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:62](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L62)

Serializable metadata returned by command handlers and copied into event records.

# GameboardInteractionHandlerPreset

> **GameboardInteractionHandlerPreset** = *typeof* [`GAMEBOARD_INTERACTION_HANDLER_PRESETS`](/declarative-hex-worlds/reference/index/variables/gameboard_interaction_handler_presets/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:210](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L210)

Identifier for a built-in interaction handler preset.

# GameboardInteractionHandlerStatus

> **GameboardInteractionHandlerStatus** = `"handled"` | `"blocked"` | `"ignored"`

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:56](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L56)

Result status returned by an opt-in game command handler.

# GameboardInteractionIntent

> **GameboardInteractionIntent** = `"move"` | `"interact"` | `"attack"` | `"inspect"`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:180](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L180)

High-level intent inferred from an interaction target.

# GameboardInteractionTargetInput

> **GameboardInteractionTargetInput** = `string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/) | { `actorId?`: `string`; `coordinates?`: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/) | `string`; `placementId?`: `string`; `tileKey?`: `string`; }

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:197](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L197)

Input accepted by interaction helpers when resolving a target.

## Union Members

[Section titled “Union Members”](#union-members)

`string`

***

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

***

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `actorId?`: `string`; `coordinates?`: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/) | `string`; `placementId?`: `string`; `tileKey?`: `string`; }

#### actorId?

[Section titled “actorId?”](#actorid)

> `optional` **actorId?**: `string`

Actor id to resolve directly.

#### coordinates?

[Section titled “coordinates?”](#coordinates)

> `optional` **coordinates?**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/) | `string`

Axial coordinates or tile key to resolve as a tile.

#### placementId?

[Section titled “placementId?”](#placementid)

> `optional` **placementId?**: `string`

Placement id to resolve directly.

#### tileKey?

[Section titled “tileKey?”](#tilekey)

> `optional` **tileKey?**: `string`

Tile key to resolve directly.

# GameboardInteractionTargetKind

> **GameboardInteractionTargetKind** = `"actor"` | `"placement"` | `"tile"` | `"empty"`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:176](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L176)

Kind of target resolved from a click, tile coordinate, actor id, or placement id.

# GameboardInteropEntityKind

> **GameboardInteropEntityKind** = `"tile"` | `"placement"` | `"spawn"` | `"spawn-group"` | `"patrol-route"` | `"patrol-waypoint"` | `"actor"` | `"quest"` | `"simulation"` | `"simulation-step"` | `"simulation-actor-targets"` | `"simulation-command"` | `"simulation-patrol"` | `"simulation-movement"` | `"simulation-mutation"`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:62](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L62)

Entity kind emitted by interop snapshots for external ECS adapters.

# GameboardMovementActionBundle

> **GameboardMovementActionBundle** = `ReturnType`<*typeof* [`gameboardMovementActions`](/declarative-hex-worlds/reference/index/variables/gameboardmovementactions/)>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:219](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L219)

Koota action bundle for movement-agent requests and ticks.

# GameboardMovementProfileInput

> **GameboardMovementProfileInput** = [`GameboardMovementProfileId`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementprofileid/) | [`GameboardMovementProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementprofile/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:64](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L64)

Profile id or inline profile accepted by movement APIs.

# GameboardNeighborhoodCenter

> **GameboardNeighborhoodCenter** = [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/) | `string` | `Entity`

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:304](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L304)

Input accepted when resolving the center of a neighborhood inspection.

# GameboardPatrolActionBundle

> **GameboardPatrolActionBundle** = `ReturnType`<*typeof* [`gameboardPatrolActions`](/declarative-hex-worlds/reference/index/variables/gameboardpatrolactions/)>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:224](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L224)

Koota action bundle for patrol-agent setup and ticks.

# GameboardPatrolAgentValue

> **GameboardPatrolAgentValue** = `TraitRecord`<*typeof* [`GameboardPatrolAgent`](/declarative-hex-worlds/reference/traits/variables/gameboardpatrolagent/)>

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L126)

Patrol agent trait value.

# GameboardPatrolStateValue

> **GameboardPatrolStateValue** = `TraitRecord`<*typeof* [`GameboardPatrolState`](/declarative-hex-worlds/reference/traits/variables/gameboardpatrolstate/)>

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L128)

Patrol state trait value.

# GameboardPieceRegistryAnalysisCheckMode

> **GameboardPieceRegistryAnalysisCheckMode** = `"per-piece"` | `"pool"`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:150](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L150)

Registry analysis mode for selection checks.

# GameboardPieceRole

> **GameboardPieceRole** = [`BuiltInGameboardLayoutArchetypeId`](/declarative-hex-worlds/reference/coordinates/layout/type-aliases/builtingameboardlayoutarchetypeid/) | `"custom"`

Defined in: [packages/declarative-hex-worlds/src/pieces/pieces.ts:34](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/pieces/pieces.ts#L34)

Role used to map registered pieces onto layout archetypes.

# GameboardPlacementAssetUrlResolver

> **GameboardPlacementAssetUrlResolver** = (`placement`) => `string` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:38](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L38)

Function that maps a placement to a model URL.

## Parameters

[Section titled “Parameters”](#parameters)

### placement

[Section titled “placement”](#placement)

[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

## Returns

[Section titled “Returns”](#returns)

`string` | `undefined`

# GameboardPlacementKind

> **GameboardPlacementKind** = `"terrain"` | `"road"` | `"river"` | `"coast"` | `"transition"` | `"decoration"` | `"structure"` | `"unit"` | `"prop"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:50](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L50)

Placement category used by manifests, Koota traits, layout rules, and renderers.

# GameboardPlacementLayer

> **GameboardPlacementLayer** = `"terrain"` | `"surface"` | `"feature"` | `"structure"` | `"unit"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:64](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L64)

Render and gameplay layer for a placement.

# GameboardPlacementOccupancyGuard

> **GameboardPlacementOccupancyGuard** = `boolean` | [`GameboardPlacementOccupancyGuardOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyguardoptions/)

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:257](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L257)

Occupancy guard setting used by placement mutation helpers.

# GameboardQuestActionBundle

> **GameboardQuestActionBundle** = `ReturnType`<*typeof* [`gameboardQuestActions`](/declarative-hex-worlds/reference/index/variables/gameboardquestactions/)>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:229](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L229)

Koota action bundle for quest spawning and progression.

# GameboardQuestActorReferenceRole

> **GameboardQuestActorReferenceRole** = `"actor"` | `"targetActor"`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:283](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L283)

Quest-to-actor reference role.

# GameboardQuestTileReferenceRole

> **GameboardQuestTileReferenceRole** = `"tile"` | `"targetTile"`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:302](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L302)

Quest-to-tile reference role.

# GameboardQuestValue

> **GameboardQuestValue** = `TraitRecord`<*typeof* [`GameboardQuest`](/declarative-hex-worlds/reference/traits/variables/gameboardquest/)>

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:151](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L151)

Quest trait value.

# GameboardScenarioSimulationCommandHandlerPreset

> **GameboardScenarioSimulationCommandHandlerPreset** = [`GameboardInteractionHandlerPreset`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractionhandlerpreset/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:277](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L277)

Built-in command handler preset id accepted by simulation scripts.

# GameboardScenarioSimulationStep

> **GameboardScenarioSimulationStep** = [`GameboardScenarioSimulationActorTargetCommandStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationactortargetcommandstep/) | [`GameboardScenarioSimulationCommandStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationcommandstep/) | [`GameboardScenarioSimulationActorTargetsStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationactortargetsstep/) | [`GameboardScenarioSimulationRunSystemsStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationrunsystemsstep/) | [`GameboardScenarioSimulationRemoveActorStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationremoveactorstep/) | [`GameboardScenarioSimulationRemovePlacementStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationremoveplacementstep/) | [`GameboardScenarioSimulationSpawnActorStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationspawnactorstep/) | [`GameboardScenarioSimulationSpawnPlacementStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationspawnplacementstep/) | [`GameboardScenarioSimulationUpdateActorStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationupdateactorstep/) | [`GameboardScenarioSimulationUpdatePlacementStep`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariosimulationupdateplacementstep/)

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:69](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L69)

One executable step in a deterministic scenario simulation script.

# GameboardSimulationRelationRole

> **GameboardSimulationRelationRole** = `"step"` | `"command"` | `"patrol"` | `"movement"` | `"mutation"` | `"actorTargets"` | `"sourceActor"` | `"targetActor"` | `"effectActor"` | `"effectPlacement"` | `"actor"` | `"placement"`

Defined in: [packages/declarative-hex-worlds/src/interop/interop.ts:335](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/interop.ts#L335)

Role used by simulation relation records.

# GameboardStateValue

> **GameboardStateValue** = `TraitRecord`<*typeof* [`GameboardState`](/declarative-hex-worlds/reference/traits/variables/gameboardstate/)>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:150](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L150)

Board trait value returned by `GameboardState`.

# GameboardSystemActionBundle

> **GameboardSystemActionBundle** = `ReturnType`<*typeof* [`gameboardSystemActions`](/declarative-hex-worlds/reference/index/variables/gameboardsystemactions/)>

Defined in: [packages/declarative-hex-worlds/src/runtime/runtime.ts:239](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/runtime.ts#L239)

Koota action bundle for command dispatch and game-loop system ticks.

# GameboardSystemEvent

> **GameboardSystemEvent** = [`GameboardMovementRequestedEvent`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementrequestedevent/) | [`GameboardCommandHandledEvent`](/declarative-hex-worlds/reference/index/interfaces/gameboardcommandhandledevent/) | [`GameboardCommandBlockedEvent`](/declarative-hex-worlds/reference/index/interfaces/gameboardcommandblockedevent/) | [`GameboardCommandIgnoredEvent`](/declarative-hex-worlds/reference/index/interfaces/gameboardcommandignoredevent/) | [`GameboardCommandHandlerRequiredEvent`](/declarative-hex-worlds/reference/index/interfaces/gameboardcommandhandlerrequiredevent/) | [`GameboardPatrolMoveRequestedEvent`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolmoverequestedevent/) | [`GameboardPatrolWaitingEvent`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolwaitingevent/) | [`GameboardPatrolCompletedEvent`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolcompletedevent/) | [`GameboardPatrolBlockedEvent`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolblockedevent/) | [`GameboardMovementSteppedEvent`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementsteppedevent/) | [`GameboardMovementCompletedEvent`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementcompletedevent/) | [`GameboardMovementBlockedEvent`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementblockedevent/) | [`GameboardQuestAdvancedEvent`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestadvancedevent/) | [`GameboardQuestCompletedEvent`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestcompletedevent/) | [`GameboardQuestBlockedEvent`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestblockedevent/)

Defined in: [packages/declarative-hex-worlds/src/systems/events.ts:27](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/events.ts#L27)

Event emitted by one high-level gameboard system pass.

# GameboardTerrain

> **GameboardTerrain** = [`BuiltInGameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/builtingameboardterrain/) | `string` & `object`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:38](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L38)

Terrain category for a tile. Custom strings are allowed for external packs.

# GameplayCategory

> **GameplayCategory** = *typeof* [`GAMEPLAY_CATEGORIES`](/declarative-hex-worlds/reference/index/variables/gameplay_categories/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/asset-source/spec.ts:48](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/spec.ts#L48)

# GltfPackSourceOptions

> **GltfPackSourceOptions** = [`GameboardPlacementAssetUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/)

Defined in: [packages/declarative-hex-worlds/src/asset-source/gltf-pack.ts:29](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/gltf-pack.ts#L29)

Options for a gltf-pack source: the same URL-resolution options the three bridge already accepts (explicit maps, manifest catalog, fallback resolver).

# GuideTilePermutationKind

> **GuideTilePermutationKind** = `"road"` | `"river"` | `"river-curvy"` | `"river-crossing"` | `"coast"`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:21](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L21)

Guide permutation families that must be covered by visual tests.

# HarborKind

> **HarborKind** = `"docks"` | `"shipyard"` | `"watermill"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:71](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L71)

Harbor structure variant.

# HexRotationSteps

> **HexRotationSteps** = `0` | `1` | `2` | `3` | `4` | `5`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L45)

Clockwise flat-top rotation in 60-degree steps.

# HexTileStateValue

> **HexTileStateValue** = `TraitRecord`<*typeof* [`HexTileState`](/declarative-hex-worlds/reference/traits/variables/hextilestate/)>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:152](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L152)

Full tile trait value returned by `HexTileState`.

# HillVariant

> **HillVariant** = `"A"` | `"B"` | `"C"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:69](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L69)

Hill visual variant.

# KnownClassifierTag

> **KnownClassifierTag** = *typeof* [`CLASSIFIER_TAGS`](/declarative-hex-worlds/reference/index/variables/classifier_tags/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/classifiers/classifiers.ts:28](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/classifiers/classifiers.ts#L28)

A known gameplay classifier. Custom classifiers are plain strings (see ClassifierTag).

# MountainVariant

> **MountainVariant** = `"A"` | `"B"` | `"C"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L67)

Mountain stack visual variant.

# MoveGameboardActorOptions

> **MoveGameboardActorOptions** = `Omit`<[`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/), `"at"`>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:107](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L107)

Placement update options accepted while moving an actor.

# MovementAgentValue

> **MovementAgentValue** = `TraitRecord`<*typeof* [`MovementAgent`](/declarative-hex-worlds/reference/traits/variables/movementagent/)>

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:226](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L226)

Movement agent trait value.

# MovementPathStateValue

> **MovementPathStateValue** = `TraitRecord`<*typeof* [`MovementPathState`](/declarative-hex-worlds/reference/traits/variables/movementpathstate/)>

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:228](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L228)

Movement path state trait value.

# NormalizeFit

> **NormalizeFit** = `"cover"` | `"contain"` | `"width"`

Defined in: [packages/declarative-hex-worlds/src/normalize/normalize.ts:17](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/normalize/normalize.ts#L17)

How an asset’s footprint is fit to the target cell.

# PackClassifierCategory

> **PackClassifierCategory** = `"terrain"` | `"playable"` | `"enemy"`

Defined in: [packages/declarative-hex-worlds/src/classifiers/classifiers.ts:72](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/classifiers/classifiers.ts#L72)

A recognized pack’s GAMEPLAY category, as published by the pack registry (`terrain` | `playable` | `enemy`). Passed in as a plain value so this core module never imports the CLI-domain registry — a consumer threads `packDescriptor(id).category` through [packClassifier](/declarative-hex-worlds/reference/index/functions/packclassifier/).

# PlacementClassifier

> **PlacementClassifier** = (`placement`) => readonly [`ClassifierTag`](/declarative-hex-worlds/reference/index/type-aliases/classifiertag/)\[]

Defined in: [packages/declarative-hex-worlds/src/classifiers/classifiers.ts:42](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/classifiers/classifiers.ts#L42)

A pure function that assigns zero or more classifier tags to a placement. Classifiers compose: every registered classifier runs, and their tags are unioned. A classifier inspects the placement’s kind / assetId / metadata and returns the classifiers it recognizes (or none).

## Parameters

[Section titled “Parameters”](#parameters)

### placement

[Section titled “placement”](#placement)

[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

## Returns

[Section titled “Returns”](#returns)

readonly [`ClassifierTag`](/declarative-hex-worlds/reference/index/type-aliases/classifiertag/)\[]

# PlacementStateValue

> **PlacementStateValue** = `TraitRecord`<*typeof* [`PlacementState`](/declarative-hex-worlds/reference/traits/variables/placementstate/)>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:166](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L166)

Placement trait value returned by `PlacementState`.

# PropClusterKind

> **PropClusterKind** = `"camp"` | `"harbor-support"` | `"resource-cache"` | `"stable-yard"` | `"training-yard"` | `"worksite"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:96](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L96)

Semantic prop cluster kinds for authored and generated dressing.

# PropClusterPlacement

> **PropClusterPlacement** = `"single"` | `"adjacent"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:104](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L104)

How a prop cluster is distributed around its anchor tile.

# RiverCrossing

> **RiverCrossing** = `"A"` | `"B"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:43](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L43)

River crossing guide variant.

# RoadSlope

> **RoadSlope** = `"high"` | `"low"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:41](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L41)

Road slope variant used by elevated road pieces.

# SeededGameboardDensityPresetId

> **SeededGameboardDensityPresetId** = `"trees"` | `"rocks"` | `"props"` | `"harbors"` | `"landmarks"` | `"units"`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:61](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L61)

Built-in seeded fill presets for common board decoration and encounter roles.

# SeededGameboardDensityValue

> **SeededGameboardDensityValue** = `number` | [`SeededGameboardDensityRuleOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboarddensityruleoptions/) | `false` | `null` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:64](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L64)

User-facing density value where numbers mean fill percentage and false disables a preset.

# SeededGameboardPieceFillMode

> **SeededGameboardPieceFillMode** = `"per-piece"` | `"pool"`

Defined in: [packages/declarative-hex-worlds/src/rules/rules.ts:106](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rules.ts#L106)

Strategy for converting selected registered pieces into fill rules.

# SettlementBuilding

> **SettlementBuilding** = [`FactionBuildingKind`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/factionbuildingkind/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:106](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L106)

Faction building kind accepted by settlement helpers.

# SiegeProjectileKind

> **SiegeProjectileKind** = `"catapult"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:94](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L94)

Siege projectile visual exposed by the neutral building asset set.

# TextureBindingIndex

> **TextureBindingIndex** = `ReadonlyMap`<`string`, readonly [`TextureBinding`](/declarative-hex-worlds/reference/index/interfaces/texturebinding/)\[]>

Defined in: [packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts:30](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/texture-binding/texture-binding.ts#L30)

A map of asset id → its texture bindings, for quick lookup during load.

# TileConnectivityValue

> **TileConnectivityValue** = `TraitRecord`<*typeof* [`TileConnectivity`](/declarative-hex-worlds/reference/traits/variables/tileconnectivity/)>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:160](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L160)

Decomposed connectivity trait value returned by `TileConnectivity`.

# TileCoordinatesValue

> **TileCoordinatesValue** = `TraitRecord`<*typeof* [`TileCoordinates`](/declarative-hex-worlds/reference/traits/variables/tilecoordinates/)>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:154](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L154)

Decomposed coordinate trait value returned by `TileCoordinates`.

# TileElevationValue

> **TileElevationValue** = `TraitRecord`<*typeof* [`TileElevation`](/declarative-hex-worlds/reference/traits/variables/tileelevation/)>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:158](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L158)

Decomposed elevation trait value returned by `TileElevation`.

# TileRenderStateValue

> **TileRenderStateValue** = `TraitRecord`<*typeof* [`TileRenderState`](/declarative-hex-worlds/reference/traits/variables/tilerenderstate/)>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:162](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L162)

Decomposed render trait value returned by `TileRenderState`.

# TilesetBiome

> **TilesetBiome** = `z.infer`<*typeof* `biomeSchema`>

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts:95](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts#L95)

# TilesetBiomeSelector

> **TilesetBiomeSelector** = *typeof* [`TILESET_BIOME_SELECTORS`](/declarative-hex-worlds/reference/index/variables/tileset_biome_selectors/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts:39](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts#L39)

# TilesetGrid

> **TilesetGrid** = `z.infer`<*typeof* `tilesetGridSchema`>

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts:27](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts#L27)

# TilesetManifest

> **TilesetManifest** = `z.infer`<*typeof* [`tilesetManifestSchema`](/declarative-hex-worlds/reference/index/variables/tilesetmanifestschema/)>

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts#L128)

# TilesetSheet

> **TilesetSheet** = `z.infer`<*typeof* `sheetSchema`>

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts:89](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts#L89)

# TilesetSheetRole

> **TilesetSheetRole** = *typeof* [`TILESET_SHEET_ROLES`](/declarative-hex-worlds/reference/index/variables/tileset_sheet_roles/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts:35](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts#L35)

# TileTagListValue

> **TileTagListValue** = `TraitRecord`<*typeof* [`TileTagList`](/declarative-hex-worlds/reference/traits/variables/tiletaglist/)>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:164](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L164)

Decomposed tag trait value returned by `TileTagList`.

# TileTerrainValue

> **TileTerrainValue** = `TraitRecord`<*typeof* [`TileTerrain`](/declarative-hex-worlds/reference/traits/variables/tileterrain/)>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:156](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L156)

Decomposed terrain trait value returned by `TileTerrain`.

# TransitionFamily

> **TransitionFamily** = keyof *typeof* [`TRANSITION_VARIANTS`](/declarative-hex-worlds/reference/index/variables/transition_variants/)

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:125](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L125)

A transition family key (`'road' | 'river' | 'coast'`).

# WallFortificationSegment

> **WallFortificationSegment** = `"straight"` | `"straight-gate"` | `"corner-A-gate"` | `"corner-A-inside"` | `"corner-A-outside"` | `"corner-B-inside"` | `"corner-B-outside"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:79](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L79)

Wall segment shape from the neutral wall asset set.

# ActiveGameboardQuestQuery

> `const` **ActiveGameboardQuestQuery**: `Query`<\[`TagTrait`, `TagTrait`, `Trait`<{ `activeObjectiveIndex`: `number`; `metadata`: () => `Record`<`string`, [`GameboardQuestMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestmetadatavalue/)>; `objectives`: () => [`GameboardQuestObjective`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestobjective/)\[]; `progress`: () => [`GameboardQuestObjectiveProgress`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectiveprogress/)\[]; `questId`: `string`; `schemaVersion`: `string`; `status`: [`GameboardQuestStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardqueststatus/); `title`: `string`; }>]>

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:144](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L144)

Query for active quest entities.

# ActiveMovementQuery

> `const` **ActiveMovementQuery**: `Query`<\[`TagTrait`, `TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>, `Trait`<{ `movementBudget`: `number`; `profileId`: [`GameboardMovementProfileId`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementprofileid/); `remainingMovement`: `number`; }>, `Trait`<{ `cost`: `number`; `destinationKey`: `string`; `nextIndex`: `number`; `pathKeys`: () => `string`\[]; `reason`: `string` | `undefined`; `spentCost`: `number`; `status`: [`GameboardMovementStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementstatus/); `visited`: `number`; }>]>

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:215](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L215)

Query for placements currently advancing along a path.

# ASSET_FORMATS

> `const` **ASSET\_FORMATS**: readonly \[`"png"`, `"glb"`, `"gltf"`]

Defined in: [packages/declarative-hex-worlds/src/asset-source/spec.ts:27](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/spec.ts#L27)

The asset file formats. Closed set.

# ASSET_ROLES

> `const` **ASSET\_ROLES**: readonly \[`"tile"`, `"tileset"`, `"sprite"`, `"model"`]

Defined in: [packages/declarative-hex-worlds/src/asset-source/spec.ts:23](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/spec.ts#L23)

The asset roles a source can declare. Closed set.

# assetSchema

> `const` **assetSchema**: `ZodDiscriminatedUnion`<\[`ZodObject`<{ `biome`: `ZodString`; `edgeMask`: `ZodOptional`<`ZodNumber`>; `format`: `ZodEnum`<{ `glb`: `"glb"`; `gltf`: `"gltf"`; `png`: `"png"`; }>; `id`: `ZodString`; `path`: `ZodString`; `role`: `ZodLiteral`<`"tile"`>; }, `$strip`>, `ZodObject`<{ `biome`: `ZodOptional`<`ZodString`>; `format`: `ZodLiteral`<`"png"`>; `grid`: `ZodObject`<{ `cellHeight`: `ZodNumber`; `cellWidth`: `ZodNumber`; `cols`: `ZodNumber`; `rows`: `ZodNumber`; }, `$strip`>; `id`: `ZodString`; `path`: `ZodString`; `role`: `ZodLiteral`<`"tileset"`>; `transition`: `ZodOptional`<`ZodObject`<{ `edgeCells`: `ZodRecord`<`ZodString`, `ZodNumber`>; }, `$strip`>>; }, `$strip`>, `ZodObject`<{ `category`: `ZodOptional`<`ZodEnum`<{ `encounter`: `"encounter"`; `enemy`: `"enemy"`; `npc`: `"npc"`; `pc`: `"pc"`; `prop`: `"prop"`; `structure`: `"structure"`; `unit`: `"unit"`; }>>; `format`: `ZodLiteral`<`"png"`>; `id`: `ZodString`; `path`: `ZodString`; `role`: `ZodLiteral`<`"sprite"`>; }, `$strip`>, `ZodObject`<{ `category`: `ZodOptional`<`ZodEnum`<{ `encounter`: `"encounter"`; `enemy`: `"enemy"`; `npc`: `"npc"`; `pc`: `"pc"`; `prop`: `"prop"`; `structure`: `"structure"`; `unit`: `"unit"`; }>>; `format`: `ZodEnum`<{ `glb`: `"glb"`; `gltf`: `"gltf"`; }>; `id`: `ZodString`; `path`: `ZodString`; `role`: `ZodLiteral`<`"model"`>; }, `$strip`>], `"role"`>

Defined in: [packages/declarative-hex-worlds/src/asset-source/spec.ts:119](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/spec.ts#L119)

One asset, discriminated by role so per-role format/field rules apply.

# assetSourceSpecSchema

> `const` **assetSourceSpecSchema**: `ZodObject`<{ `assetRoot`: `ZodString`; `assets`: `ZodArray`<`ZodDiscriminatedUnion`<\[`ZodObject`<{ `biome`: `ZodString`; `edgeMask`: `ZodOptional`<`ZodNumber`>; `format`: `ZodEnum`<{ `glb`: `"glb"`; `gltf`: `"gltf"`; `png`: `"png"`; }>; `id`: `ZodString`; `path`: `ZodString`; `role`: `ZodLiteral`<`"tile"`>; }, `$strip`>, `ZodObject`<{ `biome`: `ZodOptional`<`ZodString`>; `format`: `ZodLiteral`<`"png"`>; `grid`: `ZodObject`<{ `cellHeight`: `ZodNumber`; `cellWidth`: `ZodNumber`; `cols`: `ZodNumber`; `rows`: `ZodNumber`; }, `$strip`>; `id`: `ZodString`; `path`: `ZodString`; `role`: `ZodLiteral`<`"tileset"`>; `transition`: `ZodOptional`<`ZodObject`<{ `edgeCells`: `ZodRecord`<…, …>; }, `$strip`>>; }, `$strip`>, `ZodObject`<{ `category`: `ZodOptional`<`ZodEnum`<{ `encounter`: `"encounter"`; `enemy`: `"enemy"`; `npc`: `"npc"`; `pc`: `"pc"`; `prop`: `"prop"`; `structure`: `"structure"`; `unit`: `"unit"`; }>>; `format`: `ZodLiteral`<`"png"`>; `id`: `ZodString`; `path`: `ZodString`; `role`: `ZodLiteral`<`"sprite"`>; }, `$strip`>, `ZodObject`<{ `category`: `ZodOptional`<`ZodEnum`<{ `encounter`: `"encounter"`; `enemy`: `"enemy"`; `npc`: `"npc"`; `pc`: `"pc"`; `prop`: `"prop"`; `structure`: `"structure"`; `unit`: `"unit"`; }>>; `format`: `ZodEnum`<{ `glb`: `"glb"`; `gltf`: `"gltf"`; }>; `id`: `ZodString`; `path`: `ZodString`; `role`: `ZodLiteral`<`"model"`>; }, `$strip`>], `"role"`>>; `name`: `ZodString`; `specVersion`: `ZodLiteral`<`1`>; }, `$strip`>

Defined in: [packages/declarative-hex-worlds/src/asset-source/spec.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/spec.ts#L128)

A complete asset source: a named set of assets under an asset root.

# BIOME_KEYWORDS

> `const` **BIOME\_KEYWORDS**: readonly \[`"grass"`, `"water"`, `"coast"`, `"desert"`, `"sand"`, `"snow"`, `"ice"`, `"forest"`, `"hill"`, `"mountain"`, `"rock"`, `"road"`, `"river"`, `"lava"`, `"swamp"`]

Defined in: [packages/declarative-hex-worlds/src/asset-source/scan.ts:93](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/scan.ts#L93)

Known biome keywords the tile-biome heuristic looks for in a filename. Exported so the interactive `init` wizard can offer them as the biome-override choices (single source — the heuristic and the picker share one list).

# BlockedGameboardQuestQuery

> `const` **BlockedGameboardQuestQuery**: `Query`<\[`TagTrait`, `TagTrait`, `Trait`<{ `activeObjectiveIndex`: `number`; `metadata`: () => `Record`<`string`, [`GameboardQuestMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestmetadatavalue/)>; `objectives`: () => [`GameboardQuestObjective`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestobjective/)\[]; `progress`: () => [`GameboardQuestObjectiveProgress`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectiveprogress/)\[]; `questId`: `string`; `schemaVersion`: `string`; `status`: [`GameboardQuestStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardqueststatus/); `title`: `string`; }>]>

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:148](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L148)

Query for blocked quest entities.

# BlockingActorQuery

> `const` **BlockingActorQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>, `TagTrait`, `Trait`<{ `actorId`: `string`; `blocksMovement`: `boolean`; `faction`: `string` | `undefined`; `hostile`: `boolean`; `interactive`: `boolean`; `kind`: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/); `metadata`: () => `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>; `tags`: () => `string`\[]; `team`: `string` | `undefined`; }>]>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:675](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L675)

Query for movement-blocking actor placements.

# CLASSIFIER_TAG_PREFIX

> `const` **CLASSIFIER\_TAG\_PREFIX**: `"classifier:"` = `'classifier:'`

Defined in: [packages/declarative-hex-worlds/src/classifiers/classifiers.ts:34](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/classifiers/classifiers.ts#L34)

The `<classifier>:` prefix under which classifier tags live in a placement’s tag list.

# CLASSIFIER_TAGS

> `const` **CLASSIFIER\_TAGS**: readonly \[`"playable"`, `"non-playable"`, `"enemy"`, `"random-encounter"`, `"unit"`, `"building"`, `"prop"`]

Defined in: [packages/declarative-hex-worlds/src/classifiers/classifiers.ts:17](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/classifiers/classifiers.ts#L17)

The first-class classifier vocabulary. Consumers may also use custom string tags.

# COAST_VARIANTS

> `const` **COAST\_VARIANTS**: readonly \[[`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/)]

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:103](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L103)

Coast variants from the KayKit guide with canonical water-edge masks.

# CoastPlacementQuery

> `const` **CoastPlacementQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>]>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:139](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L139)

Query for coast placements.

# CompletedGameboardQuestQuery

> `const` **CompletedGameboardQuestQuery**: `Query`<\[`TagTrait`, `TagTrait`, `Trait`<{ `activeObjectiveIndex`: `number`; `metadata`: () => `Record`<`string`, [`GameboardQuestMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestmetadatavalue/)>; `objectives`: () => [`GameboardQuestObjective`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestobjective/)\[]; `progress`: () => [`GameboardQuestObjectiveProgress`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectiveprogress/)\[]; `questId`: `string`; `schemaVersion`: `string`; `status`: [`GameboardQuestStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardqueststatus/); `title`: `string`; }>]>

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:146](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L146)

Query for completed quest entities.

# DecomposedGameboardTileQuery

> `const` **DecomposedGameboardTileQuery**: `Query`<\[`TagTrait`, `Trait`<{ `key`: `string`; `q`: `number`; `r`: `number`; }>, `Trait`<{ `terrain`: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/); }>, `Trait`<{ `baseAssetId`: `string`; `elevation`: `number`; `supportAssetId`: `string`; }>, `Trait`<{ `coastEdges`: `number`; `coastWaterless`: `boolean`; `riverCrossing`: `"A"` | `"B"` | `undefined`; `riverCurvy`: `boolean`; `riverEdges`: `number`; `riverWaterless`: `boolean`; `roadEdges`: `number`; `roadSlope`: `"high"` | `"low"` | `undefined`; }>, `Trait`<{ `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; }>, `Trait`<() => `string`\[]>]>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:121](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L121)

Query for decomposed tile traits used by rule and ECS adapters.

# DEFAULT_CAMERA_STATE

> `const` **DEFAULT\_CAMERA\_STATE**: [`CameraState`](/declarative-hex-worlds/reference/index/interfaces/camerastate/)

Defined in: [packages/declarative-hex-worlds/src/camera/camera.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/camera/camera.ts#L58)

The default game camera: isometric, orthographic, framing the whole board.

# DEFAULT_GAMEBOARD_ASSET_ROOT

> `const` **DEFAULT\_GAMEBOARD\_ASSET\_ROOT**: `"models"` = `'models'`

Defined in: [packages/declarative-hex-worlds/src/runtime/asset-root.ts:34](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/asset-root.ts#L34)

Default consumer asset root when no override is configured. Consumers set this via `HEX_WORLDS_ASSET_ROOT` env var or `setGameboardAssetRoot` to match their framework’s static-file root (e.g. `public/models` for Vite). The bare `'models'` default works for CLI/Node consumers where the process CWD is the project root and bootstrap outputs to `./models`.

# DEFAULT_PLACEMENT_CLASSIFIERS

> `const` **DEFAULT\_PLACEMENT\_CLASSIFIERS**: readonly [`PlacementClassifier`](/declarative-hex-worlds/reference/index/type-aliases/placementclassifier/)\[]

Defined in: [packages/declarative-hex-worlds/src/classifiers/classifiers.ts:50](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/classifiers/classifiers.ts#L50)

The default classifiers — a renderer/pack-agnostic baseline derived from the placement’s structural KIND. Recognized-pack classifiers (Adventurers → playable, Skeletons → enemy/random-encounter) layer ON TOP of these via [packClassifier](/declarative-hex-worlds/reference/index/functions/packclassifier/) (RFC0-TAGb); a consumer composes `[...DEFAULT_PLACEMENT_CLASSIFIERS, ...packClassifiers()]`.

# EnemyActorQuery

> `const` **EnemyActorQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>, `TagTrait`, `Trait`<{ `actorId`: `string`; `blocksMovement`: `boolean`; `faction`: `string` | `undefined`; `hostile`: `boolean`; `interactive`: `boolean`; `kind`: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/); `metadata`: () => `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>; `tags`: () => `string`\[]; `team`: `string` | `undefined`; }>]>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:647](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L647)

Query for enemy actor placements.

# ExtraPlacementQuery

> `const` **ExtraPlacementQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>]>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:147](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L147)

Query for placements backed by local-only EXTRA assets.

# GAMEBOARD_ASSET_ROOT_ENV_VAR

> `const` **GAMEBOARD\_ASSET\_ROOT\_ENV\_VAR**: `"HEX_WORLDS_ASSET_ROOT"` = `'HEX_WORLDS_ASSET_ROOT'`

Defined in: [packages/declarative-hex-worlds/src/runtime/asset-root.ts:40](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/asset-root.ts#L40)

Environment variable name read by [resolveGameboardAssetRoot](/declarative-hex-worlds/reference/index/functions/resolvegameboardassetroot/) when no higher-priority override is configured.

# GAMEBOARD_ASSET_ROOT_GLOBAL_KEY

> `const` **GAMEBOARD\_ASSET\_ROOT\_GLOBAL\_KEY**: `"HEX_WORLDS_ASSET_ROOT"` = `'HEX_WORLDS_ASSET_ROOT'`

Defined in: [packages/declarative-hex-worlds/src/runtime/asset-root.ts:46](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/runtime/asset-root.ts#L46)

Property on `globalThis` consulted by [resolveGameboardAssetRoot](/declarative-hex-worlds/reference/index/functions/resolvegameboardassetroot/) before falling back to the env var.

# GAMEBOARD_INTERACTION_HANDLER_PRESETS

> `const` **GAMEBOARD\_INTERACTION\_HANDLER\_PRESETS**: readonly \[`"remove-target-actor"`, `"remove-target-placement"`, `"mark-target-interacted"`, `"default-rpg"`]

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:200](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L200)

Built-in handler presets for common SimpleRPG-style interactions.

# GAMEBOARD_MOVEMENT_PROFILES

> `const` **GAMEBOARD\_MOVEMENT\_PROFILES**: [`GameboardMovementProfileRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementprofileregistry/)

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:150](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L150)

Built-in movement profiles for ground units, workers, cavalry, ships, and flying units.

# GAMEBOARD_REQUIRED_BROWSER_SCREENSHOT_ARTIFACTS

> `const` **GAMEBOARD\_REQUIRED\_BROWSER\_SCREENSHOT\_ARTIFACTS**: readonly \[`"tests/browser/__screenshots__/free-catalog.png"`, `"tests/browser/__screenshots__/free-guide-assets-by-public-role.png"`, `"tests/browser/__screenshots__/free-guide-source-pages.png"`, `"tests/browser/__screenshots__/free-guide-scenarios-by-extracted-page.png"`, `"tests/browser/__screenshots__/free-guide-roads-all-labels-rotations.png"`, `"tests/browser/__screenshots__/free-guide-rivers-all-labels-rotations-water-waterless.png"`, `"tests/browser/__screenshots__/free-guide-river-curvy-crossings-all-modes.png"`, `"tests/browser/__screenshots__/free-guide-coasts-all-labels-rotations-water-waterless.png"`, `"tests/browser/__screenshots__/free-guide-page-nature-stacks-buildings-props.png"`, `"tests/browser/__screenshots__/free-gameboard-recipe.png"`, `"tests/browser/__screenshots__/free-blueprint-builder-showcase.png"`, `"tests/browser/__screenshots__/free-seeded-gameboard.png"`, `"tests/browser/__screenshots__/free-seeded-hex-gameboard.png"`, `"tests/browser/__screenshots__/free-generated-piece-recipe.png"`, `"tests/browser/__screenshots__/extra-local-all-tiles-guide-and-transitions.png"`, `"tests/browser/__screenshots__/extra-local-all-buildings-factions-neutral-harbors.png"`, `"tests/browser/__screenshots__/extra-local-all-decoration-nature-props.png"`, `"tests/browser/__screenshots__/extra-local-all-units-full-accent-neutral-siege.png"`, `"tests/browser/__screenshots__/extra-guide-assets-by-public-role.png"`, `"tests/browser/__screenshots__/extra-guide-scenarios-pages-02-15.png"`, `"tests/browser/__screenshots__/extra-guide-scenarios-pages-16-18.png"`, `"tests/browser/__screenshots__/extra-seasonal-textures.png"`, `"tests/browser/__screenshots__/extra-harbor-gameboard.png"`, `"tests/browser/__screenshots__/extra-blueprint-biome-transition-showcase.png"`]

Defined in: [packages/declarative-hex-worlds/src/interop/internal.ts:14](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/internal.ts#L14)

Browser screenshot artifacts enforced by the visual test scripts.

# GAMEBOARD_SCENARIO_SCHEMA_VERSION

> `const` **GAMEBOARD\_SCENARIO\_SCHEMA\_VERSION**: `"1.0.0"` = `'1.0.0'`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:53](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L53)

Current schema version for serialized scenario files.

# GAMEBOARD_SCENARIO_SIMULATION_SCHEMA_VERSION

> `const` **GAMEBOARD\_SCENARIO\_SIMULATION\_SCHEMA\_VERSION**: `"1.0.0"` = `'1.0.0'`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L58)

Current JSON schema version for scenario simulation scripts and reports.

# GAMEBOARD_SCENARIO_SIMULATION_STEP_ACTIONS

> `const` **GAMEBOARD\_SCENARIO\_SIMULATION\_STEP\_ACTIONS**: readonly \[`"actor-target-command"`, `"command"`, `"inspect-actor-targets"`, `"run-systems"`, `"remove-actor"`, `"remove-placement"`, `"spawn-actor"`, `"spawn-placement"`, `"update-actor"`, `"update-placement"`] = `SIMULATION_STEP_ACTIONS`

Defined in: [packages/declarative-hex-worlds/src/simulation/script-types.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/simulation/script-types.ts#L65)

Supported simulation step action discriminators. Canonical table lives in `./internal` (as `SIMULATION_STEP_ACTIONS`); re-exported here under the public name so the cycle-prone guards can stay in `./internal`.

# gameboardActions

> `const` **gameboardActions**: `Actions`<{ `canOccupyPlacement`: (`options`) => `boolean`; `clear`: () => `void`; `inspectPlacementOccupancy`: (`options`) => [`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/); `loadPlan`: (`plan`) => [`GameboardEntityIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardentityindex/); `movePlacement`: (`placement`, `to`, `options`) => `Entity`; `removePlacement`: (`placement`) => `boolean`; `spawnPlacement`: (`options`) => `Entity`; `updatePlacement`: (`placement`, `options`) => `Entity`; }>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:367](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L367)

Koota action bundle for loading, clearing, inspecting, and mutating a board through world-bound helpers.

# gameboardActorActions

> `const` **gameboardActorActions**: `Actions`<{ `collision`: (`actor`, `target`, `profile`) => [`GameboardActorCollisionReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionreport/); `command`: (`target`, `options`) => [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/); `interaction`: (`target`, `options`) => [`GameboardInteractionTargetReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetreport/); `move`: (`actor`, `to`, `options`) => `Entity`; `navigationProfile`: (`actor`, `options`) => [`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/); `neighborhood`: (`center`, `options`) => [`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/); `read`: () => [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]; `register`: (`placement`, `options`) => `Entity`; `select`: (`options`) => [`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/); `spawn`: (`options`) => `Entity`; `targets`: (`options`) => [`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/); `tile`: (`coordinates`, `options`) => [`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/); `update`: (`actor`, `options`) => `Entity`; }>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:698](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L698)

Koota action bundle for actor spawning, registration, selection, inspection, targeting, and command planning.

# GameboardActorQuery

> `const` **GameboardActorQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>, `TagTrait`, `Trait`<{ `actorId`: `string`; `blocksMovement`: `boolean`; `faction`: `string` | `undefined`; `hostile`: `boolean`; `interactive`: `boolean`; `kind`: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/); `metadata`: () => `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>; `tags`: () => `string`\[]; `team`: `string` | `undefined`; }>]>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:626](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L626)

Query for every gameplay actor placement.

# gameboardCommandActions

> `const` **gameboardCommandActions**: `Actions`<{ `execute`: (`commandOrTarget`, `options`) => [`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/); `plan`: (`target`, `options`) => [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/); `preview`: (`commandOrTarget`, `options`) => [`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/); `targetCommand`: (`options`) => [`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/); }>

Defined in: [packages/declarative-hex-worlds/src/commands/commands.ts:309](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/commands/commands.ts#L309)

Koota action bundle for planning, previewing, executing, and targeting interaction commands in a live world.

# gameboardMovementActions

> `const` **gameboardMovementActions**: `Actions`<{ `advance`: (`placement`, `options`) => [`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/); `clear`: (`placement`) => `Entity`; `reachable`: (`placement`, `options`) => [`GameboardReachableTile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardreachabletile/)\[]; `requestMove`: (`placement`, `destination`, `options`) => [`GameboardMovementRequestResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementrequestresult/); `resetBudget`: (`placement?`, `options`) => readonly `Entity`\[]; `runSystem`: (`options`) => [`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)\[]; `setAgent`: (`placement`, `options`) => `Entity`; }>

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:234](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L234)

Koota action bundle for movement agents, path requests, reachability, and advancement.

# gameboardPatrolActions

> `const` **gameboardPatrolActions**: `Actions`<{ `advance`: (`placement`, `options`) => [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/); `clear`: (`placement`) => `Entity`; `read`: () => [`GameboardPatrolSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/)\[]; `run`: (`options`) => [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)\[]; `set`: (`placement`, `options`) => `Entity`; }>

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:145](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L145)

Koota action bundle for patrol setup, clearing, advancement, and reads.

# GameboardPatrolAgentQuery

> `const` **GameboardPatrolAgentQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>, `TagTrait`, `Trait`<{ `active`: `boolean`; `currentWaypointIndex`: `number`; `loop`: `boolean`; `pauseTicks`: `number`; `roundsCompleted`: `number`; `routeId`: `string`; `segmentCosts`: () => `number`\[]; `targetWaypointIndex`: `number`; `waitTicksRemaining`: `number`; `waypointKeys`: () => `string`\[]; }>, `Trait`<{ `lastPathKeys`: () => `string`\[]; `reason`: `string` | `undefined`; `status`: [`GameboardPatrolStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardpatrolstatus/); `targetKey`: `string`; }>]>

Defined in: [packages/declarative-hex-worlds/src/patrol/patrol.ts:117](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/patrol/patrol.ts#L117)

Query for every patrol agent placement.

# GameboardPlacementQuery

> `const` **GameboardPlacementQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>]>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:131](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L131)

Query for all board placements.

# gameboardQuestActions

> `const` **gameboardQuestActions**: `Actions`<{ `advance`: (`quest`, `options`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/); `advanceAll`: (`options`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]; `find`: (`quest`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/) | `undefined`; `read`: () => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]; `spawn`: (`definition`, `options`) => `Entity`; }>

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:156](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L156)

Koota action bundle for spawning, advancing, reading, and finding quests.

# GameboardQuestQuery

> `const` **GameboardQuestQuery**: `Query`<\[`TagTrait`, `Trait`<{ `activeObjectiveIndex`: `number`; `metadata`: () => `Record`<`string`, [`GameboardQuestMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestmetadatavalue/)>; `objectives`: () => [`GameboardQuestObjective`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestobjective/)\[]; `progress`: () => [`GameboardQuestObjectiveProgress`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectiveprogress/)\[]; `questId`: `string`; `schemaVersion`: `string`; `status`: [`GameboardQuestStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardqueststatus/); `title`: `string`; }>]>

Defined in: [packages/declarative-hex-worlds/src/quests/quests.ts:142](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/quests/quests.ts#L142)

Query for all quest entities.

# gameboardSystemActions

> `const` **gameboardSystemActions**: `Actions`<{ `dispatchActorTargetCommand`: (`options`, `commandOptions`) => [`DispatchGameboardActorTargetCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardactortargetcommandresult/); `dispatchCommand`: (`commandOrTarget`, `options`) => [`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/); `interact`: (`commandOrTarget`, `options`) => [`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/); `interactActorTarget`: (`options`, `interactionOptions`) => [`RunGameboardActorTargetInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardactortargetinteractionresult/); `run`: (`options`) => [`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/); }>

Defined in: [packages/declarative-hex-worlds/src/systems/systems.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/systems.ts#L88)

Koota action bundle for high-level game-loop dispatch and system ticks.

# GameboardTileQuery

> `const` **GameboardTileQuery**: `Query`<\[`TagTrait`, `Trait`<{ `baseAssetId`: `string`; `coastEdges`: `number`; `coastWaterless`: `boolean`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `key`: `string`; `riverCrossing`: `"A"` | `"B"` | `undefined`; `riverCurvy`: `boolean`; `riverEdges`: `number`; `riverWaterless`: `boolean`; `roadEdges`: `number`; `roadSlope`: `"high"` | `"low"` | `undefined`; `supportAssetId`: `string`; `tags`: () => `string`\[]; `terrain`: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/); `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; }>]>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:119](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L119)

Query for full tile state.

# GAMEPLAY_CATEGORIES

> `const` **GAMEPLAY\_CATEGORIES**: readonly \[`"unit"`, `"pc"`, `"npc"`, `"enemy"`, `"encounter"`, `"prop"`, `"structure"`]

Defined in: [packages/declarative-hex-worlds/src/asset-source/spec.ts:39](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/spec.ts#L39)

A SUGGESTED gameplay category for a model/sprite asset — what it should be in a game, orthogonal to its `role` (which is the asset TYPE). A downloaded pack (e.g. KayKit Adventurers → `pc`, Skeletons → `enemy`) or a `bind` scan declares these as DEFAULTS the developer accepts or overrides; the engine never forces a category. `unit` = a player/AI-controlled piece; `pc`/`npc` = playable/non-playable character; `enemy` = hostile; `encounter` = a random-encounter spawn; `prop` = decoration; `structure` = a building. `undefined` = uncategorized (a plain model).

# HarborPlacementQuery

> `const` **HarborPlacementQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>]>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:143](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L143)

Query for harbor-capable placements.

# HEX_DIRECTIONS

> `const` **HEX\_DIRECTIONS**: readonly \[[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/), [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/), [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/), [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/), [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/), [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)]

Defined in: [packages/declarative-hex-worlds/src/coordinates/coordinates.ts:12](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/coordinates/coordinates.ts#L12)

Axial neighbor offsets ordered clockwise for the library edge convention.

# HEX_EDGE_COUNT

> `const` **HEX\_EDGE\_COUNT**: `6` = `6`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:63](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L63)

Number of edges on every hex tile.

# HEX_ROTATION_RADIANS

> `const` **HEX\_ROTATION\_RADIANS**: `number`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L65)

Rotation in radians for one clockwise hex edge step.

# HEX_ROTATION_STEPS

> `const` **HEX\_ROTATION\_STEPS**: readonly \[`0`, `1`, `2`, `3`, `4`, `5`]

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L67)

All valid clockwise 60-degree rotation steps.

# HostileActorQuery

> `const` **HostileActorQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>, `TagTrait`, `Trait`<{ `actorId`: `string`; `blocksMovement`: `boolean`; `faction`: `string` | `undefined`; `hostile`: `boolean`; `interactive`: `boolean`; `kind`: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/); `metadata`: () => `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>; `tags`: () => `string`\[]; `team`: `string` | `undefined`; }>]>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:661](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L661)

Query for hostile actor placements.

# InteractiveActorQuery

> `const` **InteractiveActorQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>, `TagTrait`, `Trait`<{ `actorId`: `string`; `blocksMovement`: `boolean`; `faction`: `string` | `undefined`; `hostile`: `boolean`; `interactive`: `boolean`; `kind`: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/); `metadata`: () => `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>; `tags`: () => `string`\[]; `team`: `string` | `undefined`; }>]>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:668](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L668)

Query for interactive actor placements.

# MovementAgentQuery

> `const` **MovementAgentQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>, `Trait`<{ `movementBudget`: `number`; `profileId`: [`GameboardMovementProfileId`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementprofileid/); `remainingMovement`: `number`; }>]>

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:213](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L213)

Query for placements with movement agents.

# NpcActorQuery

> `const` **NpcActorQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>, `TagTrait`, `Trait`<{ `actorId`: `string`; `blocksMovement`: `boolean`; `faction`: `string` | `undefined`; `hostile`: `boolean`; `interactive`: `boolean`; `kind`: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/); `metadata`: () => `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>; `tags`: () => `string`\[]; `team`: `string` | `undefined`; }>]>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:640](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L640)

Query for NPC actor placements.

# PlayerActorQuery

> `const` **PlayerActorQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>, `TagTrait`, `Trait`<{ `actorId`: `string`; `blocksMovement`: `boolean`; `faction`: `string` | `undefined`; `hostile`: `boolean`; `interactive`: `boolean`; `kind`: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/); `metadata`: () => `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>; `tags`: () => `string`\[]; `team`: `string` | `undefined`; }>]>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:633](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L633)

Query for player actor placements.

# PropActorQuery

> `const` **PropActorQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>, `TagTrait`, `Trait`<{ `actorId`: `string`; `blocksMovement`: `boolean`; `faction`: `string` | `undefined`; `hostile`: `boolean`; `interactive`: `boolean`; `kind`: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/); `metadata`: () => `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>; `tags`: () => `string`\[]; `team`: `string` | `undefined`; }>]>

Defined in: [packages/declarative-hex-worlds/src/actors/actors.ts:654](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/actors/actors.ts#L654)

Query for prop actor placements.

# RIVER_VARIANTS

> `const` **RIVER\_VARIANTS**: readonly \[[`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/)]

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:87](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L87)

River variants from the KayKit guide with canonical edge masks.

# RiverPlacementQuery

> `const` **RiverPlacementQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>]>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:137](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L137)

Query for river placements.

# ROAD_VARIANTS

> `const` **ROAD\_VARIANTS**: readonly \[[`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/)]

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:70](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L70)

Road variants from the KayKit guide with canonical edge masks.

# RoadPlacementQuery

> `const` **RoadPlacementQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>]>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:135](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L135)

Query for road placements.

# SOURCE_PACK_METADATA_KEY

> `const` **SOURCE\_PACK\_METADATA\_KEY**: `"sourcePack"` = `'sourcePack'`

Defined in: [packages/declarative-hex-worlds/src/classifiers/classifiers.ts:99](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/classifiers/classifiers.ts#L99)

The metadata key under which a placement records the id of the pack it was sourced from. [packClassifier](/declarative-hex-worlds/reference/index/functions/packclassifier/) reads this (or an `assetId` prefix) to decide whether a placement belongs to a recognized pack.

# StackedTerrainQuery

> `const` **StackedTerrainQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>]>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:145](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L145)

Query for stacked or elevated terrain placements.

# StructurePlacementQuery

> `const` **StructurePlacementQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>]>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:141](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L141)

Query for structure placements.

# TerrainPlacementQuery

> `const` **TerrainPlacementQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>]>

Defined in: [packages/declarative-hex-worlds/src/koota/koota.ts:133](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/koota/koota.ts#L133)

Query for terrain placements.

# TILESET_BIOME_SELECTORS

> `const` **TILESET\_BIOME\_SELECTORS**: readonly \[`"hash"`, `"first"`]

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts:38](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts#L38)

Biome selection strategy across a fill sheet’s usable cells.

# TILESET_SHEET_ROLES

> `const` **TILESET\_SHEET\_ROLES**: readonly \[`"fill"`, `"transition"`]

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts:34](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts#L34)

A sheet’s role in the tiling:

* `fill`: cells are interchangeable variations of one biome (pick by hash).
* `transition`: cells are positional — an edge mask selects a specific cell.

# tilesetManifestSchema

> `const` **tilesetManifestSchema**: `ZodObject`<{ `biomes`: `ZodRecord`<`ZodString`, `ZodObject`<{ `select`: `ZodEnum`<{ `first`: `"first"`; `hash`: `"hash"`; }>; `sheet`: `ZodString`; }, `$strip`>>; `kind`: `ZodLiteral`<`"tileset"`>; `schemaVersion`: `ZodString`; `sheets`: `ZodRecord`<`ZodString`, `ZodObject`<{ `edgeCells`: `ZodOptional`<`ZodRecord`<`ZodString`, `ZodNumber`>>; `grid`: `ZodObject`<{ `cellHeight`: `ZodNumber`; `cellWidth`: `ZodNumber`; `cols`: `ZodNumber`; `rows`: `ZodNumber`; }, `$strip`>; `role`: `ZodEnum`<{ `fill`: `"fill"`; `transition`: `"transition"`; }>; `url`: `ZodString`; `variants`: `ZodOptional`<`ZodArray`<`ZodNumber`>>; }, `$strip`>>; }, `$strip`>

Defined in: [packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts:98](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/tileset-manifest.ts#L98)

The full tileset manifest schema.

# TRANSITION_VARIANTS

> `const` **TRANSITION\_VARIANTS**: `object`

Defined in: [packages/declarative-hex-worlds/src/selectors/selectors.ts:118](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/selectors/selectors.ts#L118)

The transition families that resolve an edge mask to a rotated variant (RFC0-9b). Any AssetSource can drive its `resolveEdge` off this table: it is the renderer-neutral edge → variant seam. A tileset maps the chosen variant’s canonical mask to a sheet cell; a gltf-pack maps the variant’s assetId to a model URL and bakes the rotation into the transform.

## Type Declaration

[Section titled “Type Declaration”](#type-declaration)

### coast

[Section titled “coast”](#coast)

> `readonly` **coast**: readonly \[[`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/)] = `COAST_VARIANTS`

### river

[Section titled “river”](#river)

> `readonly` **river**: readonly \[[`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/)] = `RIVER_VARIANTS`

### road

[Section titled “road”](#road)

> `readonly` **road**: readonly \[[`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/), [`CanonicalVariant`](/declarative-hex-worlds/reference/index/interfaces/canonicalvariant/)] = `ROAD_VARIANTS`

# UnitMovementQuery

> `const` **UnitMovementQuery**: `Query`<\[`TagTrait`, `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>, `Trait`<{ `movementBudget`: `number`; `profileId`: [`GameboardMovementProfileId`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementprofileid/); `remainingMovement`: `number`; }>]>

Defined in: [packages/declarative-hex-worlds/src/movement/movement.ts:223](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/movement/movement.ts#L223)

Query for unit placements that have movement agents.

# copyGltfTree

> **copyGltfTree**(`sourceRoot`, `destinationRoot`): `void`

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:143](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L143)

Copy the complete `Assets/gltf` tree into an output folder.

Existing output is replaced so generated package assets stay reproducible.

## Parameters

[Section titled “Parameters”](#parameters)

### sourceRoot

[Section titled “sourceRoot”](#sourceroot)

`string`

### destinationRoot

[Section titled “destinationRoot”](#destinationroot)

`string`

## Returns

[Section titled “Returns”](#returns)

`void`

# defaultSourceRoot

> **defaultSourceRoot**(`edition`, `cwd?`): `string`

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:111](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L111)

Resolve the conventional gitignored source folder for a pack edition.

## Parameters

[Section titled “Parameters”](#parameters)

### edition

[Section titled “edition”](#edition)

`"free"` | `"extra"`

### cwd?

[Section titled “cwd?”](#cwd)

`string` = `...`

## Returns

[Section titled “Returns”](#returns)

`string`

# expectedModelCount

> **expectedModelCount**(`edition`): `number`

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:104](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L104)

Return the expected GLTF model count for a KayKit pack edition.

## Parameters

[Section titled “Parameters”](#parameters)

### edition

[Section titled “edition”](#edition)

`"free"` | `"extra"`

## Returns

[Section titled “Returns”](#returns)

`number`

# generateManifestFromSource

> **generateManifestFromSource**(`options`): [`MedievalHexagonManifest`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifest/)

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:165](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L165)

Generate a normalized manifest by inspecting every GLTF in a local pack.

Bounds, buffers, textures, material slots, taxonomy fields, and license metadata are derived from source files and the known KayKit edition.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`GenerateManifestOptions`](/declarative-hex-worlds/reference/ingest/interfaces/generatemanifestoptions/)

## Returns

[Section titled “Returns”](#returns)

[`MedievalHexagonManifest`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifest/)

# validateSourceRoot

> **validateSourceRoot**(`sourceRoot`, `edition`): [`ValidateSourceResult`](/declarative-hex-worlds/reference/ingest/interfaces/validatesourceresult/)

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:125](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L125)

Count local GLTF files and compare them against the known edition count.

The helper does not throw when the source is absent, which lets CLI `doctor` and build scripts report a clear local setup status.

## Parameters

[Section titled “Parameters”](#parameters)

### sourceRoot

[Section titled “sourceRoot”](#sourceroot)

`string`

### edition

[Section titled “edition”](#edition)

`"free"` | `"extra"`

## Returns

[Section titled “Returns”](#returns)

[`ValidateSourceResult`](/declarative-hex-worlds/reference/ingest/interfaces/validatesourceresult/)

# writeManifestJson

> **writeManifestJson**(`manifest`, `outputPath`): `void`

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:260](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L260)

Write a generated manifest as formatted JSON.

## Parameters

[Section titled “Parameters”](#parameters)

### manifest

[Section titled “manifest”](#manifest)

[`MedievalHexagonManifest`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifest/)

### outputPath

[Section titled “outputPath”](#outputpath)

`string`

## Returns

[Section titled “Returns”](#returns)

`void`

# writeManifestModule

> **writeManifestModule**(`manifest`, `outputPath`, `options?`): `void`

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:205](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L205)

Write a TypeScript module that exports a generated manifest.

## Parameters

[Section titled “Parameters”](#parameters)

### manifest

[Section titled “manifest”](#manifest)

[`MedievalHexagonManifest`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifest/)

### outputPath

[Section titled “outputPath”](#outputpath)

`string`

### options?

[Section titled “options?”](#options)

[`WriteManifestModuleOptions`](/declarative-hex-worlds/reference/ingest/interfaces/writemanifestmoduleoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

`void`

# GenerateManifestOptions

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:61](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L61)

Options for scanning a local KayKit source folder into a package manifest.

This is a Node/build-time API for app-local FREE or EXTRA ingest pipelines; it is not intended for browser runtime imports.

## Properties

[Section titled “Properties”](#properties)

### edition

[Section titled “edition”](#edition)

> **edition**: `"free"` | `"extra"`

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L65)

Pack edition being scanned.

***

### generatedAt?

[Section titled “generatedAt?”](#generatedat)

> `optional` **generatedAt?**: `string`

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L67)

Stable timestamp override for reproducible generated manifests.

***

### sourceRoot

[Section titled “sourceRoot”](#sourceroot)

> **sourceRoot**: `string`

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:63](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L63)

Root folder of a KayKit Medieval Hexagon pack containing `Assets/gltf`.

# ValidateSourceResult

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:73](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L73)

Source validation summary for a local KayKit pack folder.

## Properties

[Section titled “Properties”](#properties)

### edition

[Section titled “edition”](#edition)

> **edition**: `"free"` | `"extra"`

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:77](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L77)

Pack edition expected at the source root.

***

### expectedCount

[Section titled “expectedCount”](#expectedcount)

> **expectedCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:81](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L81)

Expected model count for the requested edition.

***

### gltfCount

[Section titled “gltfCount”](#gltfcount)

> **gltfCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:79](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L79)

Number of `.gltf` files found under `Assets/gltf`.

***

### ok

[Section titled “ok”](#ok)

> **ok**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:83](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L83)

Whether the discovered count exactly matches the edition expectation.

***

### sourceRoot

[Section titled “sourceRoot”](#sourceroot)

> **sourceRoot**: `string`

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:75](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L75)

Source root that was checked.

# WriteManifestModuleOptions

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:89](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L89)

Options for emitting a TypeScript manifest module.

## Properties

[Section titled “Properties”](#properties)

### exportName?

[Section titled “exportName?”](#exportname)

> `optional` **exportName?**: `string`

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:91](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L91)

Export identifier to use instead of the edition default.

***

### typeImportPath?

[Section titled “typeImportPath?”](#typeimportpath)

> `optional` **typeImportPath?**: `string`

Defined in: [packages/declarative-hex-worlds/src/ingest/ingest.ts:93](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/ingest/ingest.ts#L93)

Type import specifier written into the generated module.

# analyzeExternalAssetCompatibility

> **analyzeExternalAssetCompatibility**(`input`): [`ExternalAssetCompatibilityReport`](/declarative-hex-worlds/reference/interop/compatibility/interfaces/externalassetcompatibilityreport/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:215](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L215)

Evaluates an external GLB/GLTF against KayKit hex dimensions and returns the placement role, scale, facing, animation, warning, and error data needed for local piece registration.

## Parameters

[Section titled “Parameters”](#parameters)

### input

[Section titled “input”](#input)

[`ExternalAssetCompatibilityInput`](/declarative-hex-worlds/reference/interop/compatibility/interfaces/externalassetcompatibilityinput/)

## Returns

[Section titled “Returns”](#returns)

[`ExternalAssetCompatibilityReport`](/declarative-hex-worlds/reference/interop/compatibility/interfaces/externalassetcompatibilityreport/)

# externalAssetSpawnOptions

> **externalAssetSpawnOptions**(`input`): [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:263](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L263)

Converts an external compatibility report into `spawnGameboardPlacement` options, preserving local-only metadata and marking the placement as EXTRA.

## Parameters

[Section titled “Parameters”](#parameters)

### input

[Section titled “input”](#input)

[`ExternalAssetSpawnOptionsInput`](/declarative-hex-worlds/reference/interop/compatibility/interfaces/externalassetspawnoptionsinput/)

## Returns

[Section titled “Returns”](#returns)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)

# recommendExternalAssetFacing

> **recommendExternalAssetFacing**(`options?`): [`ExternalAssetFacingRecommendation`](/declarative-hex-worlds/reference/interop/compatibility/interfaces/externalassetfacingrecommendation/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:294](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L294)

Computes the nearest hex-step yaw correction for a model-local forward axis.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`ExternalAssetFacingOptions`](/declarative-hex-worlds/reference/interop/compatibility/interfaces/externalassetfacingoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`ExternalAssetFacingRecommendation`](/declarative-hex-worlds/reference/interop/compatibility/interfaces/externalassetfacingrecommendation/)

# ExternalAssetCompatibilityInput

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:42](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L42)

Metadata extracted from, or supplied alongside, one external GLB/GLTF.

## Properties

[Section titled “Properties”](#properties)

### animationNames?

[Section titled “animationNames?”](#animationnames)

> `optional` **animationNames?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L58)

Animation clip names discovered in the model.

***

### boardForwardEdge?

[Section titled “boardForwardEdge?”](#boardforwardedge)

> `optional` **boardForwardEdge?**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:64](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L64)

Desired board edge the model should face after placement.

***

### bounds

[Section titled “bounds”](#bounds)

> **bounds**: [`AssetBounds`](/declarative-hex-worlds/reference/types/interfaces/assetbounds/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:52](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L52)

Bounds extracted from model geometry.

***

### creator?

[Section titled “creator?”](#creator)

> `optional` **creator?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:48](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L48)

Optional creator attribution.

***

### hasRig?

[Section titled “hasRig?”](#hasrig)

> `optional` **hasRig?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:56](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L56)

Whether the model has a skin/armature.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:44](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L44)

Stable external asset id.

***

### intendedRole?

[Section titled “intendedRole?”](#intendedrole)

> `optional` **intendedRole?**: [`ExternalAssetIntendedRole`](/declarative-hex-worlds/reference/interop/compatibility/type-aliases/externalassetintendedrole/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:54](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L54)

How the caller hoped to use the asset before fit analysis.

***

### license?

[Section titled “license?”](#license)

> `optional` **license?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:50](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L50)

Optional license label for docs or local reports.

***

### materialSlots?

[Section titled “materialSlots?”](#materialslots)

> `optional` **materialSlots?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:60](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L60)

Material slot names discovered in the model.

***

### modelForward?

[Section titled “modelForward?”](#modelforward)

> `optional` **modelForward?**: [`ExternalAssetForwardAxis`](/declarative-hex-worlds/reference/interop/compatibility/type-aliases/externalassetforwardaxis/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:62](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L62)

Model-local forward axis for facing correction.

***

### sourcePack

[Section titled “sourcePack”](#sourcepack)

> **sourcePack**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:46](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L46)

Human-readable source pack name, such as `Kenney Castle Kit`.

# ExternalAssetCompatibilityReport

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:162](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L162)

Complete compatibility report for one external asset.

## Properties

[Section titled “Properties”](#properties)

### compatibleAsTile

[Section titled “compatibleAsTile”](#compatibleastile)

> **compatibleAsTile**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:168](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L168)

Whether the model can act as a KayKit-shaped tile without overrides.

***

### errors

[Section titled “errors”](#errors)

> **errors**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:178](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L178)

Fatal issues that make placement unsafe.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:164](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L164)

Stable external asset id.

***

### placement

[Section titled “placement”](#placement)

> **placement**: [`ExternalAssetPlacementRecommendation`](/declarative-hex-worlds/reference/interop/compatibility/interfaces/externalassetplacementrecommendation/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:174](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L174)

Placement metadata suitable for custom piece registration.

***

### sourcePack

[Section titled “sourcePack”](#sourcepack)

> **sourcePack**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:166](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L166)

Source pack label.

***

### suggestedRole

[Section titled “suggestedRole”](#suggestedrole)

> **suggestedRole**: [`ExternalAssetSuggestedRole`](/declarative-hex-worlds/reference/interop/compatibility/type-aliases/externalassetsuggestedrole/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:172](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L172)

Suggested role after analysis.

***

### tile

[Section titled “tile”](#tile)

> **tile**: [`ExternalAssetTileCompatibility`](/declarative-hex-worlds/reference/interop/compatibility/interfaces/externalassettilecompatibility/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:170](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L170)

Tile-fit measurements.

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:176](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L176)

Non-fatal issues a build tool or editor should show.

# ExternalAssetFacingOptions

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L136)

Input for hex-edge facing correction.

## Properties

[Section titled “Properties”](#properties)

### boardForwardEdge?

[Section titled “boardForwardEdge?”](#boardforwardedge)

> `optional` **boardForwardEdge?**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:140](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L140)

Board edge the model should face. Defaults to edge `1`.

***

### modelForward?

[Section titled “modelForward?”](#modelforward)

> `optional` **modelForward?**: [`ExternalAssetForwardAxis`](/declarative-hex-worlds/reference/interop/compatibility/type-aliases/externalassetforwardaxis/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:138](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L138)

Model-local forward axis. Defaults to `+z`.

# ExternalAssetFacingRecommendation

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:146](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L146)

Facing correction expressed in both hex rotation steps and radians.

## Properties

[Section titled “Properties”](#properties)

### boardForwardEdge

[Section titled “boardForwardEdge”](#boardforwardedge)

> **boardForwardEdge**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:150](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L150)

Target board edge after placement.

***

### facingErrorRadians

[Section titled “facingErrorRadians”](#facingerrorradians)

> **facingErrorRadians**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:156](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L156)

Remaining angle error after quantizing to hex steps.

***

### modelForward

[Section titled “modelForward”](#modelforward)

> **modelForward**: [`ExternalAssetForwardAxis`](/declarative-hex-worlds/reference/interop/compatibility/type-aliases/externalassetforwardaxis/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:148](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L148)

Model-local forward axis used for the calculation.

***

### rotationRadians

[Section titled “rotationRadians”](#rotationradians)

> **rotationRadians**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:154](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L154)

Rotation in radians.

***

### rotationSteps

[Section titled “rotationSteps”](#rotationsteps)

> **rotationSteps**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:152](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L152)

Clockwise 60-degree rotation steps.

# ExternalAssetPlacementRecommendation

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:93](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L93)

Placement metadata a game can apply when registering the external asset as a custom gameboard piece or runtime placement.

## Properties

[Section titled “Properties”](#properties)

### anchor

[Section titled “anchor”](#anchor)

> **anchor**: [`ExternalAssetAnchor`](/declarative-hex-worlds/reference/interop/compatibility/type-aliases/externalassetanchor/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:115](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L115)

Anchor point the recommendation assumes.

***

### animation?

[Section titled “animation?”](#animation)

> `optional` **animation?**: `object`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:121](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L121)

Animation recommendation when embedded clips are present.

#### clips

[Section titled “clips”](#clips)

> **clips**: readonly `string`\[]

Available clip names.

#### defaultClip?

[Section titled “defaultClip?”](#defaultclip)

> `optional` **defaultClip?**: `string`

Preferred default clip for idle/walk presentation.

#### loop

[Section titled “loop”](#loop)

> **loop**: `boolean`

Whether the clip should loop by default.

#### source

[Section titled “source”](#source)

> **source**: `"embedded"` | `"external"`

Where clips were discovered.

***

### blocksMovement

[Section titled “blocksMovement”](#blocksmovement)

> **blocksMovement**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:113](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L113)

Whether the placement should block actor movement by default.

***

### boardForwardEdge

[Section titled “boardForwardEdge”](#boardforwardedge)

> **boardForwardEdge**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:119](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L119)

Board edge the model is intended to face.

***

### elevationOffset

[Section titled “elevationOffset”](#elevationoffset)

> **elevationOffset**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:105](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L105)

Vertical offset to place the model on top of the hex surface.

***

### facingErrorRadians

[Section titled “facingErrorRadians”](#facingerrorradians)

> **facingErrorRadians**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:111](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L111)

Remaining angle error after hex-step rotation.

***

### footprint

[Section titled “footprint”](#footprint)

> **footprint**: [`ExternalAssetFootprintKind`](/declarative-hex-worlds/reference/interop/compatibility/type-aliases/externalassetfootprintkind/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:101](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L101)

Inferred footprint family.

***

### kind

[Section titled “kind”](#kind)

> **kind**: `"unit"` | `"prop"` | `"terrain"` | `"structure"`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:97](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L97)

Gameboard placement kind to use.

***

### layer

[Section titled “layer”](#layer)

> **layer**: `"unit"` | `"terrain"` | `"structure"` | `"feature"`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:99](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L99)

Gameboard render/collision layer to use.

***

### modelForward

[Section titled “modelForward”](#modelforward)

> **modelForward**: [`ExternalAssetForwardAxis`](/declarative-hex-worlds/reference/interop/compatibility/type-aliases/externalassetforwardaxis/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:117](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L117)

Model-local forward axis used for this recommendation.

***

### role

[Section titled “role”](#role)

> **role**: [`ExternalAssetSuggestedRole`](/declarative-hex-worlds/reference/interop/compatibility/type-aliases/externalassetsuggestedrole/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:95](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L95)

Suggested high-level role.

***

### rotationRadians

[Section titled “rotationRadians”](#rotationradians)

> **rotationRadians**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:109](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L109)

Rotation in radians equivalent to `rotationSteps`.

***

### rotationSteps

[Section titled “rotationSteps”](#rotationsteps)

> **rotationSteps**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:107](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L107)

60-degree rotation steps needed for best facing alignment.

***

### scale

[Section titled “scale”](#scale)

> **scale**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:103](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L103)

Recommended uniform scale.

# ExternalAssetSpawnOptionsInput

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:184](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L184)

Input for converting a compatibility report into runtime spawn options.

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:190](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L190)

Asset id used by the host app or local source URL map.

***

### at

[Section titled “at”](#at)

> **at**: `string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:188](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L188)

Target tile for the placement.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:186](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L186)

Optional placement id.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:202](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L202)

Extra metadata merged after compatibility metadata.

***

### report

[Section titled “report”](#report)

> **report**: [`ExternalAssetCompatibilityReport`](/declarative-hex-worlds/reference/interop/compatibility/interfaces/externalassetcompatibilityreport/)

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:192](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L192)

Compatibility report produced for the asset.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:198](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L198)

Optional rotation override.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:200](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L200)

Optional scale override.

***

### sourcePack?

[Section titled “sourcePack?”](#sourcepack)

> `optional` **sourcePack?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:196](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L196)

Optional source pack override for metadata.

***

### sourceUrl?

[Section titled “sourceUrl?”](#sourceurl)

> `optional` **sourceUrl?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:194](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L194)

Optional model URL, often a Vite `@fs` URL in local tests.

# ExternalAssetTileCompatibility

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:70](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L70)

KayKit tile-footprint fit measurements for an external model.

## Properties

[Section titled “Properties”](#properties)

### aspectRatio

[Section titled “aspectRatio”](#aspectratio)

> **aspectRatio**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:80](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L80)

Model width/depth ratio.

***

### aspectRatioDelta

[Section titled “aspectRatioDelta”](#aspectratiodelta)

> **aspectRatioDelta**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:84](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L84)

Absolute ratio difference.

***

### compatible

[Section titled “compatible”](#compatible)

> **compatible**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:72](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L72)

True when width/depth ratio and scale are close enough for a KayKit tile.

***

### depthScale

[Section titled “depthScale”](#depthscale)

> **depthScale**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:76](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L76)

Uniform board depth divided by model depth.

***

### expectedAspectRatio

[Section titled “expectedAspectRatio”](#expectedaspectratio)

> **expectedAspectRatio**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:82](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L82)

KayKit tile width/depth ratio.

***

### scaleMismatch

[Section titled “scaleMismatch”](#scalemismatch)

> **scaleMismatch**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L86)

Relative difference between width and depth scale.

***

### uniformScale

[Section titled “uniformScale”](#uniformscale)

> **uniformScale**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:78](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L78)

Smaller of width/depth scale, useful for safe prop scaling.

***

### widthScale

[Section titled “widthScale”](#widthscale)

> **widthScale**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:74](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L74)

Uniform board width divided by model width.

# ExternalAssetAnchor

> **ExternalAssetAnchor** = `"center"` | `"bottom-center"`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:37](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L37)

Placement anchor recommendation for external models.

# ExternalAssetFootprintKind

> **ExternalAssetFootprintKind** = `"hex"` | `"circle"` | `"square"` | `"rectangle"` | `"point"`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:26](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L26)

Coarse footprint shape inferred for an external asset.

# ExternalAssetForwardAxis

> **ExternalAssetForwardAxis** = `"+x"` | `"-x"` | `"+z"` | `"-z"`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:32](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L32)

Model-local forward axis used to align rigged units or directional props to a board edge.

# ExternalAssetIntendedRole

> **ExternalAssetIntendedRole** = `"tile"` | `"prop"` | `"structure"` | `"unit"`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:15](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L15)

Intended use for an external GLB/GLTF before the compatibility pass evaluates whether it actually fits KayKit hex geometry.

# ExternalAssetSuggestedRole

> **ExternalAssetSuggestedRole** = `"tile"` | `"prop"` | `"unit"`

Defined in: [packages/declarative-hex-worlds/src/interop/compatibility.ts:21](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/compatibility.ts#L21)

Role suggested by the compatibility pass after bounds, rig, and requested role are considered.

# createDefaultGameboardCoveragePackageChecks

> **createDefaultGameboardCoveragePackageChecks**(`status?`): [`GameboardCoveragePackageCheck`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragepackagecheck/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:422](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L422)

Builds the default release gate command rows without executing commands.

## Parameters

[Section titled “Parameters”](#parameters)

### status?

[Section titled “status?”](#status)

[`GameboardCoverageCheckStatus`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/gameboardcoveragecheckstatus/) = `'not-run'`

## Returns

[Section titled “Returns”](#returns)

[`GameboardCoveragePackageCheck`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragepackagecheck/)\[]

# createDefaultGameboardCoverageReferences

> **createDefaultGameboardCoverageReferences**(`status?`): [`GameboardCoverageReference`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereference/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:380](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L380)

Builds the default local reference-pack status inputs without probing the filesystem. The CLI upgrades these statuses from `skipped` to `available` or `missing` during a workspace scan.

## Parameters

[Section titled “Parameters”](#parameters)

### status?

[Section titled “status?”](#status)

[`GameboardCoverageStatus`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/gameboardcoveragestatus/) = `'skipped'`

## Returns

[Section titled “Returns”](#returns)

[`GameboardCoverageReference`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereference/)\[]

# renderGameboardCoverageMarkdown

> **renderGameboardCoverageMarkdown**(`report?`): `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:510](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L510)

Renders a release-readiness report as a Markdown ledger.

## Parameters

[Section titled “Parameters”](#parameters)

### report?

[Section titled “report?”](#report)

[`GameboardCoverageReport`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereport/) = `...`

## Returns

[Section titled “Returns”](#returns)

`string`

# summarizeGameboardCoverage

> **summarizeGameboardCoverage**(`options?`): [`GameboardCoverageReport`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereport/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:441](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L441)

Summarizes guide-page coverage, manifest coverage, public APIs, visual artifacts, local references, package gates, and release gaps.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`SummarizeGameboardCoverageOptions`](/declarative-hex-worlds/reference/interop/coverage/interfaces/summarizegameboardcoverageoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardCoverageReport`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereport/)

# CoverageGap

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:85](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L85)

Stable machine-readable release-readiness gap.

## Properties

[Section titled “Properties”](#properties)

### code

[Section titled “code”](#code)

> **code**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:87](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L87)

Stable code for docs, tests, and CI parsing.

***

### message

[Section titled “message”](#message)

> **message**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:91](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L91)

Human-readable explanation.

***

### severity

[Section titled “severity”](#severity)

> **severity**: [`CoverageGapSeverity`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/coveragegapseverity/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:89](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L89)

Whether the gap blocks release, needs review, or is informational.

***

### subject?

[Section titled “subject?”](#subject)

> `optional` **subject?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:93](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L93)

Optional source path, asset id, guide page id, or command id.

# GameboardCoverageLinkedPath

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:97](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L97)

One docs or source-image path referenced by a guide page.

## Properties

[Section titled “Properties”](#properties)

### path

[Section titled “path”](#path)

> **path**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:99](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L99)

Repo-relative source path.

***

### status

[Section titled “status”](#status)

> **status**: [`GameboardCoverageStatus`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/gameboardcoveragestatus/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:101](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L101)

Availability status supplied by the caller or CLI filesystem scan.

# GameboardCoverageManifestSummary

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:153](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L153)

Manifest coverage summary for guide-described FREE and EXTRA assets.

## Properties

[Section titled “Properties”](#properties)

### edition?

[Section titled “edition?”](#edition)

> `optional` **edition?**: `"free"` | `"extra"`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:155](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L155)

Edition declared by the inspected manifest.

***

### errorCount

[Section titled “errorCount”](#errorcount)

> **errorCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:171](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L171)

Manifest validation issue count by severity.

***

### extraGuideAssetsInManifest

[Section titled “extraGuideAssetsInManifest”](#extraguideassetsinmanifest)

> **extraGuideAssetsInManifest**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:167](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L167)

EXTRA guide assets found in the inspected manifest.

***

### extraGuideAssetsLocalOnly

[Section titled “extraGuideAssetsLocalOnly”](#extraguideassetslocalonly)

> **extraGuideAssetsLocalOnly**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:169](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L169)

EXTRA guide asset ids not present in the inspected manifest.

***

### freeGuideAssetsInManifest

[Section titled “freeGuideAssetsInManifest”](#freeguideassetsinmanifest)

> **freeGuideAssetsInManifest**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:163](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L163)

FREE guide assets found in the inspected manifest.

***

### freeGuideAssetsMissingFromManifest

[Section titled “freeGuideAssetsMissingFromManifest”](#freeguideassetsmissingfrommanifest)

> **freeGuideAssetsMissingFromManifest**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:165](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L165)

FREE guide asset ids absent from the inspected manifest.

***

### guideExtraAssetCount

[Section titled “guideExtraAssetCount”](#guideextraassetcount)

> **guideExtraAssetCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:161](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L161)

EXTRA guide assets expected to remain local-only.

***

### guideFreeAssetCount

[Section titled “guideFreeAssetCount”](#guidefreeassetcount)

> **guideFreeAssetCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:159](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L159)

FREE guide assets expected from the published package.

***

### issues

[Section titled “issues”](#issues)

> **issues**: readonly [`MedievalHexagonManifestIssue`](/declarative-hex-worlds/reference/manifest/schema/interfaces/medievalhexagonmanifestissue/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:175](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L175)

Manifest validation issues from schema inspection.

***

### manifestAssetCount

[Section titled “manifestAssetCount”](#manifestassetcount)

> **manifestAssetCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:157](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L157)

Total assets in the inspected manifest.

***

### warningCount

[Section titled “warningCount”](#warningcount)

> **warningCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:173](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L173)

Manifest validation warning count.

# GameboardCoveragePackageCheck

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:206](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L206)

Package, docs, CI, or visual command captured in the coverage ledger.

## Properties

[Section titled “Properties”](#properties)

### command

[Section titled “command”](#command)

> **command**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:212](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L212)

Command or CI check name.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:208](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L208)

Stable check id.

***

### label

[Section titled “label”](#label)

> **label**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:210](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L210)

Human-readable check label.

***

### status

[Section titled “status”](#status)

> **status**: [`GameboardCoverageCheckStatus`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/gameboardcoveragecheckstatus/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:214](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L214)

Verification status for this report.

***

### summary?

[Section titled “summary?”](#summary)

> `optional` **summary?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:216](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L216)

Optional captured output summary.

# GameboardCoveragePackageCheckInput

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:220](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L220)

Input used to override package gate command status.

## Extends

[Section titled “Extends”](#extends)

* `Partial`<`Omit`<[`GameboardCoveragePackageCheck`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragepackagecheck/), `"id"` | `"status"`>>

## Properties

[Section titled “Properties”](#properties)

### command?

[Section titled “command?”](#command)

> `optional` **command?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:212](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L212)

Command or CI check name.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardCoveragePackageCheck`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragepackagecheck/).[`command`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragepackagecheck/#command)

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:223](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L223)

Stable check id to override.

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:210](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L210)

Human-readable check label.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardCoveragePackageCheck`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragepackagecheck/).[`label`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragepackagecheck/#label)

***

### status?

[Section titled “status?”](#status)

> `optional` **status?**: [`GameboardCoverageCheckStatus`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/gameboardcoveragecheckstatus/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:225](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L225)

Verification status for this report.

***

### summary?

[Section titled “summary?”](#summary)

> `optional` **summary?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:216](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L216)

Optional captured output summary.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardCoveragePackageCheck`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragepackagecheck/).[`summary`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragepackagecheck/#summary)

# GameboardCoveragePathStatusInput

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:259](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L259)

Optional path status maps supplied by the CLI or another build tool.

## Properties

[Section titled “Properties”](#properties)

### docs?

[Section titled “docs?”](#docs)

> `optional` **docs?**: `Readonly`<`Record`<`string`, [`GameboardCoverageStatus`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/gameboardcoveragestatus/)>>

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:263](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L263)

Availability status by repo-relative docs path.

***

### sourceImages?

[Section titled “sourceImages?”](#sourceimages)

> `optional` **sourceImages?**: `Readonly`<`Record`<`string`, [`GameboardCoverageStatus`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/gameboardcoveragestatus/)>>

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:261](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L261)

Availability status by repo-relative source image path.

***

### visualArtifacts?

[Section titled “visualArtifacts?”](#visualartifacts)

> `optional` **visualArtifacts?**: `Readonly`<`Record`<`string`, [`GameboardCoverageStatus`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/gameboardcoveragestatus/)>>

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:265](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L265)

Availability status by repo-relative visual artifact path.

# GameboardCoverageReference

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:179](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L179)

Local reference pack status for optional EXTRA/reference visual coverage.

## Properties

[Section titled “Properties”](#properties)

### edition?

[Section titled “edition?”](#edition)

> `optional` **edition?**: `"free"` | `"extra"`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:189](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L189)

Optional KayKit edition represented by this reference.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:181](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L181)

Stable reference id used by docs and CLI output.

***

### label

[Section titled “label”](#label)

> **label**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:183](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L183)

Human-readable reference pack name.

***

### path

[Section titled “path”](#path)

> **path**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:185](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L185)

Repo-relative local path.

***

### purpose

[Section titled “purpose”](#purpose)

> **purpose**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:191](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L191)

Why this reference exists in the release-readiness matrix.

***

### requiredForFullReview

[Section titled “requiredForFullReview”](#requiredforfullreview)

> **requiredForFullReview**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:193](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L193)

Whether missing this reference should be treated as a warning.

***

### status

[Section titled “status”](#status)

> **status**: [`GameboardCoverageStatus`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/gameboardcoveragestatus/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:187](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L187)

Availability status from the caller or CLI filesystem scan.

# GameboardCoverageReferenceInput

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:197](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L197)

Input used to override local reference pack statuses.

## Extends

[Section titled “Extends”](#extends)

* `Partial`<`Omit`<[`GameboardCoverageReference`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereference/), `"id"` | `"status"`>>

## Properties

[Section titled “Properties”](#properties)

### edition?

[Section titled “edition?”](#edition)

> `optional` **edition?**: `"free"` | `"extra"`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:189](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L189)

Optional KayKit edition represented by this reference.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardCoverageReference`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereference/).[`edition`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereference/#edition)

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:200](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L200)

Stable reference id to override.

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:183](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L183)

Human-readable reference pack name.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardCoverageReference`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereference/).[`label`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereference/#label)

***

### path?

[Section titled “path?”](#path)

> `optional` **path?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:185](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L185)

Repo-relative local path.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardCoverageReference`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereference/).[`path`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereference/#path)

***

### purpose?

[Section titled “purpose?”](#purpose)

> `optional` **purpose?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:191](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L191)

Why this reference exists in the release-readiness matrix.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardCoverageReference`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereference/).[`purpose`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereference/#purpose)

***

### requiredForFullReview?

[Section titled “requiredForFullReview?”](#requiredforfullreview)

> `optional` **requiredForFullReview?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:193](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L193)

Whether missing this reference should be treated as a warning.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardCoverageReference`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereference/).[`requiredForFullReview`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereference/#requiredforfullreview)

***

### status?

[Section titled “status?”](#status)

> `optional` **status?**: [`GameboardCoverageStatus`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/gameboardcoveragestatus/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:202](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L202)

Availability status from a filesystem scan or caller-provided probe.

# GameboardCoverageReport

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:285](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L285)

Full release-readiness report for the package and local visual evidence.

## Properties

[Section titled “Properties”](#properties)

### assets

[Section titled “assets”](#assets)

> **assets**: readonly [`KayKitGuideAssetCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguideassetcoverage/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:303](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L303)

Asset-id-level coverage for every treated FREE and EXTRA asset.

***

### gaps

[Section titled “gaps”](#gaps)

> **gaps**: readonly [`CoverageGap`](/declarative-hex-worlds/reference/interop/coverage/interfaces/coveragegap/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:313](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L313)

Machine-readable gaps that should guide release closeout.

***

### generatedAt?

[Section titled “generatedAt?”](#generatedat)

> `optional` **generatedAt?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:289](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L289)

Optional ISO timestamp provided by the caller.

***

### guide

[Section titled “guide”](#guide)

> **guide**: [`KayKitGuideCoverageSummary`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidecoveragesummary/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:293](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L293)

Full guide scenario summary from the catalog source of truth.

***

### manifest

[Section titled “manifest”](#manifest)

> **manifest**: [`GameboardCoverageManifestSummary`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragemanifestsummary/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:297](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L297)

Manifest coverage against guide-described FREE and EXTRA assets.

***

### packageChecks

[Section titled “packageChecks”](#packagechecks)

> **packageChecks**: readonly [`GameboardCoveragePackageCheck`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragepackagecheck/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:309](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L309)

Package, docs, visual, and release verification command status.

***

### pages

[Section titled “pages”](#pages)

> **pages**: readonly [`GuidePageCoverage`](/declarative-hex-worlds/reference/interop/coverage/interfaces/guidepagecoverage/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:295](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L295)

Page-by-page guide coverage enriched with path status.

***

### publicApi

[Section titled “publicApi”](#publicapi)

> **publicApi**: readonly [`KayKitGuidePublicApiCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidepublicapicoverage/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:299](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L299)

Inverse public API coverage from guide pages and treated assets.

***

### references

[Section titled “references”](#references)

> **references**: readonly [`GameboardCoverageReference`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereference/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:307](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L307)

Local reference pack availability for EXTRA and third-party visual tests.

***

### releaseGateCommands

[Section titled “releaseGateCommands”](#releasegatecommands)

> **releaseGateCommands**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:315](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L315)

Canonical command sequence for final acceptance.

***

### roles

[Section titled “roles”](#roles)

> **roles**: readonly [`KayKitGuideRoleCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguiderolecoverage/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:301](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L301)

Inverse public gameplay-role coverage.

***

### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> **schemaVersion**: `"1.0.0"`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:287](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L287)

Report schema version.

***

### simpleRpgEvidence?

[Section titled “simpleRpgEvidence?”](#simplerpgevidence)

> `optional` **simpleRpgEvidence?**: [`GameboardCoverageSimpleRpgEvidence`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragesimplerpgevidence/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:311](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L311)

Optional SimpleRPG public API proof from the packaged example fixture.

***

### status

[Section titled “status”](#status)

> **status**: [`GameboardCoverageReportStatus`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/gameboardcoveragereportstatus/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:291](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L291)

Overall status derived from gaps and check status.

***

### visualArtifacts

[Section titled “visualArtifacts”](#visualartifacts)

> **visualArtifacts**: readonly [`VisualArtifactCoverage`](/declarative-hex-worlds/reference/interop/coverage/interfaces/visualartifactcoverage/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:305](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L305)

Screenshot and showcase artifact availability.

# GameboardCoverageSimpleRpgEvidence

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:229](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L229)

SimpleRPG public API proof joined into the release-readiness ledger.

## Properties

[Section titled “Properties”](#properties)

### activeEvidenceModes

[Section titled “activeEvidenceModes”](#activeevidencemodes)

> **activeEvidenceModes**: readonly [`GameboardCoverageSimpleRpgEvidenceMode`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/gameboardcoveragesimplerpgevidencemode/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:247](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L247)

Evidence modes with at least one represented public API.

***

### evidenceModeCounts

[Section titled “evidenceModeCounts”](#evidencemodecounts)

> **evidenceModeCounts**: `Readonly`<`Record`<[`GameboardCoverageSimpleRpgEvidenceMode`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/gameboardcoveragesimplerpgevidencemode/), `number`>>

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:245](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L245)

Evidence-mode counts; one public API may contribute to multiple modes.

***

### executablePublicApiCount

[Section titled “executablePublicApiCount”](#executablepublicapicount)

> **executablePublicApiCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:239](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L239)

Number of guide-facing helper APIs directly invoked by executable smoke.

***

### exercisedPublicApiCount

[Section titled “exercisedPublicApiCount”](#exercisedpublicapicount)

> **exercisedPublicApiCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:233](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L233)

Number of current guide-facing public API rows represented by SimpleRPG evidence.

***

### guidePublicApiCount

[Section titled “guidePublicApiCount”](#guidepublicapicount)

> **guidePublicApiCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:231](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L231)

Number of guide-facing public API rows from the catalog.

***

### guideScenarioCount

[Section titled “guideScenarioCount”](#guidescenariocount)

> **guideScenarioCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:243](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L243)

Number of decomposed guide pages asserted by executable smoke.

***

### inactiveEvidenceModes

[Section titled “inactiveEvidenceModes”](#inactiveevidencemodes)

> **inactiveEvidenceModes**: readonly [`GameboardCoverageSimpleRpgEvidenceMode`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/gameboardcoveragesimplerpgevidencemode/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:249](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L249)

Evidence modes with zero represented public APIs.

***

### missingPublicApis

[Section titled “missingPublicApis”](#missingpublicapis)

> **missingPublicApis**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:235](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L235)

Current guide-facing public APIs with no SimpleRPG evidence.

***

### publicApiExercises?

[Section titled “publicApiExercises?”](#publicapiexercises)

> `optional` **publicApiExercises?**: readonly [`GameboardCoverageSimpleRpgEvidenceRow`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragesimplerpgevidencerow/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:255](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L255)

Optional per-public-API proof rows. The CLI-generated release ledger includes this matrix so agents and downstream tools can trace aggregate counts back to the exact SimpleRPG exercise, guide pages, and screenshots.

***

### publicTreatmentCount

[Section titled “publicTreatmentCount”](#publictreatmentcount)

> **publicTreatmentCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:241](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L241)

Number of KayKit public treatment records asserted by executable smoke.

***

### stalePublicApis

[Section titled “stalePublicApis”](#stalepublicapis)

> **stalePublicApis**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:237](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L237)

SimpleRPG evidence rows that no longer map to current guide-facing public APIs.

# GameboardCoverageSimpleRpgEvidenceRow

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L65)

One SimpleRPG proof row for a guide-facing public API surface.

## Properties

[Section titled “Properties”](#properties)

### assetCount

[Section titled “assetCount”](#assetcount)

> **assetCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:79](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L79)

Unique asset count represented by this API row.

***

### evidence

[Section titled “evidence”](#evidence)

> **evidence**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:73](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L73)

Human-readable fixture, docs, or package proof.

***

### mode

[Section titled “mode”](#mode)

> **mode**: [`GameboardCoverageSimpleRpgEvidenceMode`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/gameboardcoveragesimplerpgevidencemode/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:69](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L69)

Primary evidence mode for the API.

***

### modes

[Section titled “modes”](#modes)

> **modes**: readonly [`GameboardCoverageSimpleRpgEvidenceMode`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/gameboardcoveragesimplerpgevidencemode/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:71](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L71)

All evidence modes that exercise this API, including the primary mode.

***

### pages

[Section titled “pages”](#pages)

> **pages**: readonly `number`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:75](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L75)

One-based guide pages represented by this API row.

***

### publicApi

[Section titled “publicApi”](#publicapi)

> **publicApi**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L67)

Public API surface from the guide/public-treatment catalog.

***

### scenarioIds

[Section titled “scenarioIds”](#scenarioids)

> **scenarioIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:77](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L77)

Guide scenario ids represented by this API row.

***

### visualArtifacts

[Section titled “visualArtifacts”](#visualartifacts)

> **visualArtifacts**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:81](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L81)

Visual artifacts attached to the guide scenarios behind this API row.

# GuidePageCoverage

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:121](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L121)

Release-readiness coverage for one extracted KayKit guide page.

## Properties

[Section titled “Properties”](#properties)

### assetOccurrences

[Section titled “assetOccurrences”](#assetoccurrences)

> **assetOccurrences**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:131](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L131)

Asset references on this page, counting repeated use across pages.

***

### docs

[Section titled “docs”](#docs)

> **docs**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:143](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L143)

Documentation entries attached to this page.

***

### docsCoverage

[Section titled “docsCoverage”](#docscoverage)

> **docsCoverage**: readonly [`GameboardCoverageLinkedPath`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragelinkedpath/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:147](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L147)

Documentation pages linked by this scenario plus availability status.

***

### edition

[Section titled “edition”](#edition)

> **edition**: [`KayKitGuideScenarioEdition`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitguidescenarioedition/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:129](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L129)

Edition scope represented by this page.

***

### extraAssets

[Section titled “extraAssets”](#extraassets)

> **extraAssets**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:137](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L137)

EXTRA asset ids on this page.

***

### freeAssets

[Section titled “freeAssets”](#freeassets)

> **freeAssets**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:135](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L135)

FREE asset ids on this page.

***

### page

[Section titled “page”](#page)

> **page**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:123](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L123)

One-based extracted guide page number.

***

### publicApis

[Section titled “publicApis”](#publicapis)

> **publicApis**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:139](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L139)

Public helper/API entries attached to this page.

***

### scenarioId

[Section titled “scenarioId”](#scenarioid)

> **scenarioId**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:125](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L125)

Stable guide scenario id.

***

### sourceImage

[Section titled “sourceImage”](#sourceimage)

> **sourceImage**: [`GameboardCoverageLinkedPath`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragelinkedpath/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:145](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L145)

Source guide image for this page plus availability status.

***

### title

[Section titled “title”](#title)

> **title**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:127](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L127)

Human-readable guide page title.

***

### uniqueAssets

[Section titled “uniqueAssets”](#uniqueassets)

> **uniqueAssets**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:133](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L133)

Unique asset ids on this page.

***

### visualArtifactCoverage

[Section titled “visualArtifactCoverage”](#visualartifactcoverage)

> **visualArtifactCoverage**: readonly [`VisualArtifactCoverage`](/declarative-hex-worlds/reference/interop/coverage/interfaces/visualartifactcoverage/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:149](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L149)

Visual artifacts linked by this scenario plus availability status.

***

### visualArtifacts

[Section titled “visualArtifacts”](#visualartifacts)

> **visualArtifacts**: `number`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:141](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L141)

Review artifacts attached to this page.

# SummarizeGameboardCoverageOptions

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:269](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L269)

Options for `summarizeGameboardCoverage`.

## Properties

[Section titled “Properties”](#properties)

### generatedAt?

[Section titled “generatedAt?”](#generatedat)

> `optional` **generatedAt?**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:273](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L273)

ISO timestamp for generated report consumers.

***

### manifest?

[Section titled “manifest?”](#manifest)

> `optional` **manifest?**: [`MedievalHexagonManifest`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifest/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:271](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L271)

Manifest to inspect. Defaults to the packaged FREE manifest.

***

### packageChecks?

[Section titled “packageChecks?”](#packagechecks)

> `optional` **packageChecks?**: readonly [`GameboardCoveragePackageCheckInput`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragepackagecheckinput/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:279](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L279)

Package, docs, visual, or release gate check status overrides.

***

### pathStatus?

[Section titled “pathStatus?”](#pathstatus)

> `optional` **pathStatus?**: [`GameboardCoveragePathStatusInput`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragepathstatusinput/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:275](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L275)

Caller-provided path status maps. Omitted paths are marked `skipped`.

***

### references?

[Section titled “references?”](#references)

> `optional` **references?**: readonly [`GameboardCoverageReferenceInput`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragereferenceinput/)\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:277](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L277)

Local reference pack status overrides.

***

### simpleRpgEvidence?

[Section titled “simpleRpgEvidence?”](#simplerpgevidence)

> `optional` **simpleRpgEvidence?**: [`GameboardCoverageSimpleRpgEvidence`](/declarative-hex-worlds/reference/interop/coverage/interfaces/gameboardcoveragesimplerpgevidence/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:281](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L281)

Optional SimpleRPG public API proof from the packaged example fixture.

# VisualArtifactCoverage

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:105](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L105)

One screenshot, contact sheet, guide image, or required review artifact for release.

## Properties

[Section titled “Properties”](#properties)

### pages

[Section titled “pages”](#pages)

> **pages**: readonly `number`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:115](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L115)

One-based guide pages represented by this artifact.

***

### path

[Section titled “path”](#path)

> **path**: `string`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:107](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L107)

Repo-relative screenshot, showcase, or contact-sheet path.

***

### required

[Section titled “required”](#required)

> **required**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:117](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L117)

Whether release review expects this artifact to exist.

***

### scenarioIds

[Section titled “scenarioIds”](#scenarioids)

> **scenarioIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:113](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L113)

Guide scenarios that reference this artifact.

***

### source

[Section titled “source”](#source)

> **source**: [`VisualArtifactCoverageSource`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/visualartifactcoveragesource/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:111](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L111)

Whether this artifact comes from guide visual coverage or curated showcases.

***

### status

[Section titled “status”](#status)

> **status**: [`GameboardCoverageStatus`](/declarative-hex-worlds/reference/interop/coverage/type-aliases/gameboardcoveragestatus/)

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:109](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L109)

Whether the artifact was available during the coverage scan.

# CoverageGapSeverity

> **CoverageGapSeverity** = `"info"` | `"warning"` | `"error"`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L47)

Severity for a machine-readable coverage gap.

# GameboardCoverageCheckStatus

> **GameboardCoverageCheckStatus** = `"passed"` | `"failed"` | `"not-run"` | `"skipped"`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:41](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L41)

Verification status for package, docs, CI, or release gate commands.

# GameboardCoverageReportStatus

> **GameboardCoverageReportStatus** = `"passed"` | `"warning"` | `"failed"`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:44](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L44)

Overall release-readiness status derived from coverage gaps and check status.

# GameboardCoverageSimpleRpgEvidenceMode

> **GameboardCoverageSimpleRpgEvidenceMode** = `"fixed-gameplay"` | `"seeded-generation"` | `"packaged-scenario"` | `"executable-smoke"` | `"blueprint-recipe"` | `"manifest-package"` | `"compatibility-adapter"` | `"package-boundary"` | `"visual-coverage"`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:53](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L53)

Evidence mode names used by the SimpleRPG public API integration fixture.

# GameboardCoverageStatus

> **GameboardCoverageStatus** = `"available"` | `"missing"` | `"skipped"`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:38](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L38)

Filesystem availability status for coverage inputs and screenshot artifacts.

# VisualArtifactCoverageSource

> **VisualArtifactCoverageSource** = `"guide"` | `"showcase"` | `"screenshot"`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:50](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L50)

Review artifact source class for screenshots, guide images, or required supporting files.

# GAMEBOARD_COVERAGE_SCHEMA_VERSION

> `const` **GAMEBOARD\_COVERAGE\_SCHEMA\_VERSION**: `"1.0.0"` = `'1.0.0'`

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:35](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L35)

Schema version for generated release-readiness reports.

# GAMEBOARD_CURATED_SHOWCASE_ARTIFACTS

> `const` **GAMEBOARD\_CURATED\_SHOWCASE\_ARTIFACTS**: readonly \[`"docs/showcases/free-guide-scenarios-by-extracted-page.png"`, `"docs/showcases/free-guide-roads-all-labels-rotations.png"`, `"docs/showcases/free-guide-rivers-all-labels-rotations-water-waterless.png"`, `"docs/showcases/free-guide-coasts-all-labels-rotations-water-waterless.png"`, `"docs/showcases/free-blueprint-builder-showcase.png"`, `"docs/showcases/extra-blueprint-biome-transition-showcase.png"`, `"docs/showcases/extra-harbor-gameboard.png"`]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:319](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L319)

Curated showcase artifacts promoted from browser screenshots into docs.

# GAMEBOARD_RELEASE_GATE_COMMANDS

> `const` **GAMEBOARD\_RELEASE\_GATE\_COMMANDS**: readonly \[`"pnpm lint"`, `"pnpm typecheck"`, `"pnpm build"`, `"pnpm test"`, `"pnpm test:coverage:enforce"`, `"pnpm test:browser:free"`, `"pnpm docs-site:build"`, `"npm pack --dry-run"`]

Defined in: [packages/declarative-hex-worlds/src/interop/coverage.ts:340](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/interop/coverage.ts#L340)

Canonical final acceptance commands for release closeout.

Mirrors the per-PR CI workflow (lint / typecheck / build / vitest with contract specs / coverage-enforce / docs site build / browser visual snapshot diff) plus the release-only `npm pack` step. The bespoke `audit-*.ts` scripts are gone — their assertions live in `tests/contract/` and run under `pnpm test`.

# loadFreeManifest

> **loadFreeManifest**(): `Promise`<[`MedievalHexagonManifest`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifest/)>

Defined in: [packages/declarative-hex-worlds/src/manifest/free.ts:37](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/free.ts#L37)

Async-first accessor for the FREE manifest.

## Returns

[Section titled “Returns”](#returns)

`Promise`<[`MedievalHexagonManifest`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifest/)>

## Remarks

[Section titled “Remarks”](#remarks)

The manifest is imported statically (bundled from the JSON), so this resolves immediately — it exists to give async-first consumers a stable contract. Identity-stable: every call resolves to the same reference as [freeManifest](/declarative-hex-worlds/reference/manifest/free/variables/freemanifest/).

# freeManifest

> `const` **freeManifest**: [`MedievalHexagonManifest`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifest/)

Defined in: [packages/declarative-hex-worlds/src/manifest/free.ts:26](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/free.ts#L26)

Normalized manifest for the FREE KayKit Medieval Hexagon assets bundled in the npm package.

## Remarks

[Section titled “Remarks”](#remarks)

Eager export. Consumers that want lazy / async loading should prefer [loadFreeManifest](/declarative-hex-worlds/reference/manifest/free/functions/loadfreemanifest/) instead — same data, Promise-wrapped, identity-stable.

# createManifestBundle

> **createManifestBundle**(`manifests`, `options?`): [`MedievalHexagonManifestBundle`](/declarative-hex-worlds/reference/manifest/schema/interfaces/medievalhexagonmanifestbundle/)

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:261](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L261)

Combines multiple edition manifests into one lookup catalog.

## Parameters

[Section titled “Parameters”](#parameters)

### manifests

[Section titled “manifests”](#manifests)

readonly [`MedievalHexagonManifest`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifest/)\[]

### options?

[Section titled “options?”](#options)

[`CreateManifestBundleOptions`](/declarative-hex-worlds/reference/manifest/schema/interfaces/createmanifestbundleoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`MedievalHexagonManifestBundle`](/declarative-hex-worlds/reference/manifest/schema/interfaces/medievalhexagonmanifestbundle/)

# getManifestAsset

> **getManifestAsset**(`catalog`, `assetId`): [`MedievalHexagonAsset`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonasset/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:339](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L339)

Looks up an asset in a manifest or bundle by stable asset id.

## Parameters

[Section titled “Parameters”](#parameters)

### catalog

[Section titled “catalog”](#catalog)

[`ManifestAssetCatalog`](/declarative-hex-worlds/reference/manifest/schema/type-aliases/manifestassetcatalog/)

### assetId

[Section titled “assetId”](#assetid)

`string`

## Returns

[Section titled “Returns”](#returns)

[`MedievalHexagonAsset`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonasset/) | `undefined`

# hasManifestAsset

> **hasManifestAsset**(`catalog`, `assetId`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:349](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L349)

Returns true when a manifest or bundle contains the requested asset id.

## Parameters

[Section titled “Parameters”](#parameters)

### catalog

[Section titled “catalog”](#catalog)

[`ManifestAssetCatalog`](/declarative-hex-worlds/reference/manifest/schema/type-aliases/manifestassetcatalog/)

### assetId

[Section titled “assetId”](#assetid)

`string`

## Returns

[Section titled “Returns”](#returns)

`boolean`

# inspectMedievalHexagonManifest

> **inspectMedievalHexagonManifest**(`input`): [`MedievalHexagonManifestInspection`](/declarative-hex-worlds/reference/manifest/schema/interfaces/medievalhexagonmanifestinspection/)

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:201](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L201)

Validates an unknown value and returns a normalized manifest when possible.

## Parameters

[Section titled “Parameters”](#parameters)

### input

[Section titled “input”](#input)

`unknown`

## Returns

[Section titled “Returns”](#returns)

[`MedievalHexagonManifestInspection`](/declarative-hex-worlds/reference/manifest/schema/interfaces/medievalhexagonmanifestinspection/)

# manifestAssetRequiresExtra

> **manifestAssetRequiresExtra**(`catalog`, `assetId`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:356](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L356)

Returns true for any asset that is not supplied by the published FREE edition.

## Parameters

[Section titled “Parameters”](#parameters)

### catalog

[Section titled “catalog”](#catalog)

[`ManifestAssetCatalog`](/declarative-hex-worlds/reference/manifest/schema/type-aliases/manifestassetcatalog/)

### assetId

[Section titled “assetId”](#assetid)

`string`

## Returns

[Section titled “Returns”](#returns)

`boolean`

# normalizeMedievalHexagonManifest

> **normalizeMedievalHexagonManifest**(`manifest`): [`MedievalHexagonManifest`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifest/)

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:247](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L247)

Rebuilds manifest indexes, counts, and texture-set ordering from the manifest asset list.

## Parameters

[Section titled “Parameters”](#parameters)

### manifest

[Section titled “manifest”](#manifest)

[`MedievalHexagonManifest`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifest/)

## Returns

[Section titled “Returns”](#returns)

[`MedievalHexagonManifest`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifest/)

# resolveManifestAssetUrl

> **resolveManifestAssetUrl**(`asset`, `options?`): `string`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:363](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L363)

Resolves a manifest model path against a base URL or a bootstrap asset root.

## Parameters

[Section titled “Parameters”](#parameters)

### asset

[Section titled “asset”](#asset)

[`MedievalHexagonAsset`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonasset/)

### options?

[Section titled “options?”](#options)

[`ManifestAssetUrlOptions`](/declarative-hex-worlds/reference/manifest/schema/interfaces/manifestasseturloptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

`string`

# rewriteToBootstrapPath

> **rewriteToBootstrapPath**(`asset`): `string`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:383](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L383)

Return the asset’s path relative to the bootstrap asset root. The manifest’s `modelPath` and `sourcePath` are equal and already asset-root-relative, so this is an identity pass-through. Consumers resolve the final URL via `gameboardAssetUrl(asset)` in `declarative-hex-worlds/runtime`.

## Parameters

[Section titled “Parameters”](#parameters)

### asset

[Section titled “asset”](#asset)

[`MedievalHexagonAsset`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonasset/)

## Returns

[Section titled “Returns”](#returns)

`string`

# selectManifestAssets

> **selectManifestAssets**(`catalog`, `selection?`): [`MedievalHexagonAsset`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonasset/)\[]

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:303](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L303)

Selects manifest assets by id, edition, taxonomy, faction, unit style, or texture set.

## Parameters

[Section titled “Parameters”](#parameters)

### catalog

[Section titled “catalog”](#catalog)

[`ManifestAssetCatalog`](/declarative-hex-worlds/reference/manifest/schema/type-aliases/manifestassetcatalog/)

### selection?

[Section titled “selection?”](#selection)

[`ManifestAssetSelection`](/declarative-hex-worlds/reference/manifest/schema/interfaces/manifestassetselection/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`MedievalHexagonAsset`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonasset/)\[]

# validateMedievalHexagonManifest

> **validateMedievalHexagonManifest**(`input`): [`MedievalHexagonManifestIssue`](/declarative-hex-worlds/reference/manifest/schema/interfaces/medievalhexagonmanifestissue/)\[]

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:239](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L239)

Returns only the validation issues for an unknown manifest-like value.

## Parameters

[Section titled “Parameters”](#parameters)

### input

[Section titled “input”](#input)

`unknown`

## Returns

[Section titled “Returns”](#returns)

[`MedievalHexagonManifestIssue`](/declarative-hex-worlds/reference/manifest/schema/interfaces/medievalhexagonmanifestissue/)\[]

# CreateManifestBundleOptions

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:115](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L115)

Options for `createManifestBundle`.

## Properties

[Section titled “Properties”](#properties)

### duplicatePreference?

[Section titled “duplicatePreference?”](#duplicatepreference)

> `optional` **duplicatePreference?**: [`ManifestDuplicatePreference`](/declarative-hex-worlds/reference/manifest/schema/type-aliases/manifestduplicatepreference/)

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:117](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L117)

Duplicate resolution strategy. Defaults to `last`.

# KayKitAttribution

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:56](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L56)

Attribution metadata applied to generated manifests and NOTICE guidance.

## Properties

[Section titled “Properties”](#properties)

### creator

[Section titled “creator”](#creator)

> **creator**: `string`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L58)

Creator credited by generated manifests and package NOTICE text.

***

### license

[Section titled “license”](#license)

> **license**: `"CC0-1.0"`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:62](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L62)

SPDX-style asset license label.

***

### licenseUrl

[Section titled “licenseUrl”](#licenseurl)

> **licenseUrl**: `string`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:64](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L64)

Canonical URL for the asset license terms.

***

### website

[Section titled “website”](#website)

> **website**: `string`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:60](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L60)

Public creator or KayKit website URL.

# ManifestAssetSelection

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:123](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L123)

Field filters for manifest asset queries.

## Properties

[Section titled “Properties”](#properties)

### categories?

[Section titled “categories?”](#categories)

> `optional` **categories?**: readonly (`"tiles"` | `"buildings"` | `"decoration"` | `"units"`)\[]

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:129](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L129)

Match top-level categories.

***

### editions?

[Section titled “editions?”](#editions)

> `optional` **editions?**: readonly (`"free"` | `"extra"`)\[]

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:127](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L127)

Match source editions.

***

### factions?

[Section titled “factions?”](#factions)

> `optional` **factions?**: readonly (`"blue"` | `"green"` | `"red"` | `"yellow"`)\[]

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:135](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L135)

Match faction-colored assets.

***

### families?

[Section titled “families?”](#families)

> `optional` **families?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:133](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L133)

Match normalized asset families.

***

### ids?

[Section titled “ids?”](#ids)

> `optional` **ids?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:125](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L125)

Match exact asset ids.

***

### subcategories?

[Section titled “subcategories?”](#subcategories)

> `optional` **subcategories?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:131](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L131)

Match category-specific subcategories.

***

### textureSets?

[Section titled “textureSets?”](#texturesets)

> `optional` **textureSets?**: readonly (`"default"` | `"fall"` | `"summer"` | `"winter"`)\[]

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:139](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L139)

Match texture palettes.

***

### unitStyles?

[Section titled “unitStyles?”](#unitstyles)

> `optional` **unitStyles?**: readonly (`"neutral"` | `"accent"` | `"full"`)\[]

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:137](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L137)

Match unit styles.

# ManifestAssetUrlOptions

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:145](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L145)

URL resolution options for manifest assets.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`GameboardPlacementAssetUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/)

## Properties

[Section titled “Properties”](#properties)

### baseUrl?

[Section titled “baseUrl?”](#baseurl)

> `optional` **baseUrl?**: `string` | `URL`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:147](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L147)

Base URL applied to every model path when no edition-specific base exists.

***

### bootstrapAssetRoot?

[Section titled “bootstrapAssetRoot?”](#bootstrapassetroot)

> `optional` **bootstrapAssetRoot?**: `string` | `URL`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:160](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L160)

Consumer’s bootstrap asset root (per PRD RB3).

When set, manifest `sourcePath` values (e.g. `buildings/blue/foo.gltf`) are joined with this root to produce the resolved URL — `<bootstrapAssetRoot>/<sourcePath>` (flat layout, no subdirectory prefix).

Honored only when neither [baseUrl](/declarative-hex-worlds/reference/manifest/schema/interfaces/manifestasseturloptions/#baseurl) nor a matching [editionBaseUrls](/declarative-hex-worlds/reference/manifest/schema/interfaces/manifestasseturloptions/#editionbaseurls) entry is set; explicit base URLs always win.

***

### editionBaseUrls?

[Section titled “editionBaseUrls?”](#editionbaseurls)

> `optional` **editionBaseUrls?**: `Partial`<`Record`<`"free"` | `"extra"`, `string` | `URL`>>

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:149](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L149)

Per-edition base URLs, useful when FREE is packaged and EXTRA is local.

# MedievalHexagonManifestBundle

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:80](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L80)

Combined view over one or more edition manifests.

## Properties

[Section titled “Properties”](#properties)

### assets

[Section titled “assets”](#assets)

> **assets**: readonly [`MedievalHexagonAsset`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonasset/)\[]

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:92](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L92)

De-duplicated assets selected according to duplicate preference.

***

### assetsById

[Section titled “assetsById”](#assetsbyid)

> **assetsById**: `Readonly`<`Record`<`string`, [`MedievalHexagonAsset`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonasset/)>>

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:94](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L94)

De-duplicated asset lookup by id.

***

### counts

[Section titled “counts”](#counts)

> **counts**: [`MedievalHexagonManifestCounts`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifestcounts/)

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:96](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L96)

Counts derived from de-duplicated assets.

***

### duplicateAssetIds

[Section titled “duplicateAssetIds”](#duplicateassetids)

> **duplicateAssetIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:98](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L98)

Asset ids that appeared in more than one manifest.

***

### editions

[Section titled “editions”](#editions)

> **editions**: readonly (`"free"` | `"extra"`)\[]

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L86)

Editions present in the bundle.

***

### manifests

[Section titled “manifests”](#manifests)

> **manifests**: readonly [`MedievalHexagonManifest`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifest/)\[]

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:84](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L84)

Normalized source manifests included in the bundle.

***

### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> **schemaVersion**: `"1.0.0"`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:82](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L82)

Bundle schema version.

***

### sourcePacks

[Section titled “sourcePacks”](#sourcepacks)

> **sourcePacks**: readonly [`SourcePackInfo`](/declarative-hex-worlds/reference/types/interfaces/sourcepackinfo/)\[]

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:90](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L90)

Source-pack attribution records.

***

### textureSets

[Section titled “textureSets”](#texturesets)

> **textureSets**: readonly (`"default"` | `"fall"` | `"summer"` | `"winter"`)\[]

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L88)

Texture sets present across all manifests.

# MedievalHexagonManifestInspection

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:187](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L187)

Result of validating and normalizing a manifest-like object.

## Properties

[Section titled “Properties”](#properties)

### errorCount

[Section titled “errorCount”](#errorcount)

> **errorCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:193](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L193)

Number of error-severity issues.

***

### issues

[Section titled “issues”](#issues)

> **issues**: readonly [`MedievalHexagonManifestIssue`](/declarative-hex-worlds/reference/manifest/schema/interfaces/medievalhexagonmanifestissue/)\[]

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:191](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L191)

All validation issues.

***

### manifest?

[Section titled “manifest?”](#manifest)

> `optional` **manifest?**: [`MedievalHexagonManifest`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifest/)

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:189](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L189)

Normalized manifest when no errors were found.

***

### warningCount

[Section titled “warningCount”](#warningcount)

> **warningCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:195](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L195)

Number of warning-severity issues.

# MedievalHexagonManifestIssue

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:171](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L171)

One manifest validation issue.

## Properties

[Section titled “Properties”](#properties)

### assetId?

[Section titled “assetId?”](#assetid)

> `optional` **assetId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:181](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L181)

Optional asset id associated with the issue.

***

### code

[Section titled “code”](#code)

> **code**: `string`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:173](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L173)

Stable issue code for tests and CLI output.

***

### message

[Section titled “message”](#message)

> **message**: `string`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:177](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L177)

Human-readable explanation.

***

### path?

[Section titled “path?”](#path)

> `optional` **path?**: `string`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:179](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L179)

Optional JSON path.

***

### severity

[Section titled “severity”](#severity)

> **severity**: [`MedievalHexagonManifestIssueSeverity`](/declarative-hex-worlds/reference/manifest/schema/type-aliases/medievalhexagonmanifestissueseverity/)

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:175](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L175)

Whether the issue blocks a normalized manifest.

# ManifestAssetCatalog

> **ManifestAssetCatalog** = [`MedievalHexagonManifest`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifest/) | [`MedievalHexagonManifestBundle`](/declarative-hex-worlds/reference/manifest/schema/interfaces/medievalhexagonmanifestbundle/)

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:105](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L105)

Catalog accepted by lookup helpers: either one edition manifest or a combined FREE/EXTRA bundle.

# ManifestDuplicatePreference

> **ManifestDuplicatePreference** = `"first"` | `"last"` | `"free"` | `"extra"`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:110](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L110)

Strategy for resolving duplicate asset ids when combining manifests.

# MedievalHexagonManifestIssueSeverity

> **MedievalHexagonManifestIssueSeverity** = `"error"` | `"warning"`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:166](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L166)

Severity emitted by manifest inspection.

# KAYKIT_ATTRIBUTION

> `const` **KAYKIT\_ATTRIBUTION**: `Readonly`<[`KayKitAttribution`](/declarative-hex-worlds/reference/manifest/schema/interfaces/kaykitattribution/)>

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:70](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L70)

Canonical attribution metadata for KayKit Medieval Hexagon assets.

# GameboardPlanProvider

> **GameboardPlanProvider**(`__namedParameters`): `ReactElement`<{ }>

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:346](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L346)

Create and mount a runtime from a prebuilt `GameboardPlan`.

## Parameters

[Section titled “Parameters”](#parameters)

### \_\_namedParameters

[Section titled “\_\_namedParameters”](#__namedparameters)

[`GameboardPlanProviderProps`](/declarative-hex-worlds/reference/react/interfaces/gameboardplanproviderprops/)

## Returns

[Section titled “Returns”](#returns)

`ReactElement`<{ }>

# GameboardProvider

> **GameboardProvider**(`__namedParameters`): `Element`

Defined in: node\_modules/.pnpm/koota\@0.6.6\_@<types+react@19.2.17_react>@19.2.7/node\_modules/koota/dist/react.d.ts:33

## Parameters

[Section titled “Parameters”](#parameters)

### \_\_namedParameters

[Section titled “\_\_namedParameters”](#__namedparameters)

#### children

[Section titled “children”](#children)

`ReactNode`

#### world

[Section titled “world”](#world)

`World`

## Returns

[Section titled “Returns”](#returns)

`Element`

# GameboardRecipeProvider

> **GameboardRecipeProvider**(`__namedParameters`): `ReactElement`<{ }>

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:357](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L357)

Compile a recipe, create a runtime, and mount it for React consumers.

## Parameters

[Section titled “Parameters”](#parameters)

### \_\_namedParameters

[Section titled “\_\_namedParameters”](#__namedparameters)

[`GameboardRecipeProviderProps`](/declarative-hex-worlds/reference/react/interfaces/gameboardrecipeproviderprops/)

## Returns

[Section titled “Returns”](#returns)

`ReactElement`<{ }>

# GameboardRuntimeProvider

> **GameboardRuntimeProvider**<`TRuntime`>(`__namedParameters`): `ReactElement`<{ }>

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:331](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L331)

Mount a runtime facade and expose its Koota world through `koota/react`.

This is the preferred provider when runtime creation happens outside React, because `useGameboardRuntime` returns the same object with scenario/recipe registries, source URL helpers, and live mutation methods intact.

## Type Parameters

[Section titled “Type Parameters”](#type-parameters)

### TRuntime

[Section titled “TRuntime”](#truntime)

`TRuntime` *extends* [`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/) = [`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/)

## Parameters

[Section titled “Parameters”](#parameters)

### \_\_namedParameters

[Section titled “\_\_namedParameters”](#__namedparameters)

[`GameboardRuntimeProviderProps`](/declarative-hex-worlds/reference/react/interfaces/gameboardruntimeproviderprops/)<`TRuntime`>

## Returns

[Section titled “Returns”](#returns)

`ReactElement`<{ }>

# GameboardScenarioProvider

> **GameboardScenarioProvider**(`__namedParameters`): `ReactElement`<{ }>

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:375](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L375)

Compile a scenario, create a runtime, and mount it for React consumers.

The runtime returned by `useGameboardRuntime` keeps scenario actor/quest indexes, spawn groups, patrol plans, and local source URL helpers available.

## Parameters

[Section titled “Parameters”](#parameters)

### \_\_namedParameters

[Section titled “\_\_namedParameters”](#__namedparameters)

[`GameboardScenarioProviderProps`](/declarative-hex-worlds/reference/react/interfaces/gameboardscenarioproviderprops/)

## Returns

[Section titled “Returns”](#returns)

`ReactElement`<{ }>

# useAdjacentTileEntities

> **useAdjacentTileEntities**(`entity`): readonly `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:992](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L992)

Read adjacent tile relation targets for one tile entity.

## Parameters

[Section titled “Parameters”](#parameters)

### entity

[Section titled “entity”](#entity)

`Entity` | `null` | `undefined`

## Returns

[Section titled “Returns”](#returns)

readonly `Entity`\[]

# useCanOccupyGameboardPlacement

> **useCanOccupyGameboardPlacement**(`options`): `boolean` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1365](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1365)

Return only the boolean placement-occupancy decision for form controls.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/) | `undefined`

## Returns

[Section titled “Returns”](#returns)

`boolean` | `undefined`

# useDecomposedTileEntities

> **useDecomposedTileEntities**(): readonly `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:852](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L852)

Query tile entities with their decomposed coordinate, terrain, and render traits.

## Returns

[Section titled “Returns”](#returns)

readonly `Entity`\[]

# useGameboardActions

> **useGameboardActions**(): `object`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:495](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L495)

Bind low-level board actions for loading, clearing, and spawning tile plans.

## Returns

[Section titled “Returns”](#returns)

### canOccupyPlacement

[Section titled “canOccupyPlacement”](#canoccupyplacement)

> **canOccupyPlacement**: (`options`) => `boolean`

Return only the boolean occupancy result for a proposed placement.

#### Parameters

[Section titled “Parameters”](#parameters)

##### options

[Section titled “options”](#options)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/)

#### Returns

[Section titled “Returns”](#returns-1)

`boolean`

### clear

[Section titled “clear”](#clear)

> **clear**: () => `void`

Remove all board tile, placement, and board-state traits from the world.

#### Returns

[Section titled “Returns”](#returns-2)

`void`

### inspectPlacementOccupancy

[Section titled “inspectPlacementOccupancy”](#inspectplacementoccupancy)

> **inspectPlacementOccupancy**: (`options`) => [`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/)

Inspect whether a proposed placement footprint can occupy its target tiles.

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### options

[Section titled “options”](#options-1)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/)

#### Returns

[Section titled “Returns”](#returns-3)

[`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/)

### loadPlan

[Section titled “loadPlan”](#loadplan)

> **loadPlan**: (`plan`) => [`GameboardEntityIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardentityindex/)

Replace the current world contents with a complete generated board plan.

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

#### Returns

[Section titled “Returns”](#returns-4)

[`GameboardEntityIndex`](/declarative-hex-worlds/reference/index/interfaces/gameboardentityindex/)

### movePlacement

[Section titled “movePlacement”](#moveplacement)

> **movePlacement**: (`placement`, `to`, `options`) => `Entity`

Move an existing placement to another tile while preserving unspecified state.

#### Parameters

[Section titled “Parameters”](#parameters-3)

##### placement

[Section titled “placement”](#placement)

`string` | `Entity`

##### to

[Section titled “to”](#to)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### options?

[Section titled “options?”](#options-2)

[`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-5)

`Entity`

### removePlacement

[Section titled “removePlacement”](#removeplacement)

> **removePlacement**: (`placement`) => `boolean`

Remove an existing placement by entity or placement id.

#### Parameters

[Section titled “Parameters”](#parameters-4)

##### placement

[Section titled “placement”](#placement-1)

`string` | `Entity`

#### Returns

[Section titled “Returns”](#returns-6)

`boolean`

### spawnPlacement

[Section titled “spawnPlacement”](#spawnplacement)

> **spawnPlacement**: (`options`) => `Entity`

Spawn a runtime placement into the board.

#### Parameters

[Section titled “Parameters”](#parameters-5)

##### options

[Section titled “options”](#options-3)

[`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-7)

`Entity`

### updatePlacement

[Section titled “updatePlacement”](#updateplacement)

> **updatePlacement**: (`placement`, `options`) => `Entity`

Update an existing runtime placement by entity or placement id.

#### Parameters

[Section titled “Parameters”](#parameters-6)

##### placement

[Section titled “placement”](#placement-2)

`string` | `Entity`

##### options

[Section titled “options”](#options-4)

[`UpdateGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardplacementoptions/)

#### Returns

[Section titled “Returns”](#returns-8)

`Entity`

# useGameboardActor

> **useGameboardActor**(`entity`): { `actorId`: `string`; `blocksMovement`: `boolean`; `faction`: `string` | `undefined`; `hostile`: `boolean`; `interactive`: `boolean`; `kind`: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/); `metadata`: `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>; `tags`: `string`\[]; `team`: `string` | `undefined`; } | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1026](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1026)

Read actor metadata for one actor entity.

## Parameters

[Section titled “Parameters”](#parameters)

### entity

[Section titled “entity”](#entity)

`Entity` | `null` | `undefined`

## Returns

[Section titled “Returns”](#returns)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `actorId`: `string`; `blocksMovement`: `boolean`; `faction`: `string` | `undefined`; `hostile`: `boolean`; `interactive`: `boolean`; `kind`: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/); `metadata`: `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>; `tags`: `string`\[]; `team`: `string` | `undefined`; }

#### actorId

[Section titled “actorId”](#actorid)

> **actorId**: `string` = `''`

Stable gameplay actor id.

#### blocksMovement

[Section titled “blocksMovement”](#blocksmovement)

> **blocksMovement**: `boolean` = `false`

Whether this actor blocks movement.

#### faction

[Section titled “faction”](#faction)

> **faction**: `string` | `undefined`

Optional faction identifier.

#### hostile

[Section titled “hostile”](#hostile)

> **hostile**: `boolean` = `false`

Whether this actor is generally hostile.

#### interactive

[Section titled “interactive”](#interactive)

> **interactive**: `boolean` = `false`

Whether this actor should be treated as an interaction target.

#### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/)

Actor role used by collision, targeting, commands, and fixtures.

#### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>

Serializable actor metadata.

#### tags

[Section titled “tags”](#tags)

> **tags**: `string`\[]

Free-form actor tags.

#### team

[Section titled “team”](#team)

> **team**: `string` | `undefined`

Optional team identifier.

***

`undefined`

# useGameboardActorActions

> **useGameboardActorActions**(): `object`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:511](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L511)

Bind actor actions for registering, spawning, moving, and updating actors.

## Returns

[Section titled “Returns”](#returns)

### collision

[Section titled “collision”](#collision)

> **collision**: (`actor`, `target`, `profile`) => [`GameboardActorCollisionReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionreport/)

Inspect whether an actor can enter a target tile.

#### Parameters

[Section titled “Parameters”](#parameters)

##### actor

[Section titled “actor”](#actor)

`string` | `Entity` | `undefined`

##### target

[Section titled “target”](#target)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### profile?

[Section titled “profile?”](#profile)

[`GameboardActorCollisionProfile`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionprofile/) = `{}`

#### Returns

[Section titled “Returns”](#returns-1)

[`GameboardActorCollisionReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorcollisionreport/)

### command

[Section titled “command”](#command)

> **command**: (`target`, `options`) => [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

Plan a high-level interaction command from a target input.

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### target

[Section titled “target”](#target-1)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

##### options?

[Section titled “options?”](#options)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-2)

[`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

### interaction

[Section titled “interaction”](#interaction)

> **interaction**: (`target`, `options`) => [`GameboardInteractionTargetReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetreport/)

Resolve and inspect an interaction target.

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### target

[Section titled “target”](#target-2)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

##### options?

[Section titled “options?”](#options-1)

[`GameboardInteractionTargetOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-3)

[`GameboardInteractionTargetReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetreport/)

### move

[Section titled “move”](#move)

> **move**: (`actor`, `to`, `options`) => `Entity`

Move an actor to another tile.

#### Parameters

[Section titled “Parameters”](#parameters-3)

##### actor

[Section titled “actor”](#actor-1)

`string` | `Entity`

##### to

[Section titled “to”](#to)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### options?

[Section titled “options?”](#options-2)

[`MoveGameboardActorOptions`](/declarative-hex-worlds/reference/index/type-aliases/movegameboardactoroptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-4)

`Entity`

### navigationProfile

[Section titled “navigationProfile”](#navigationprofile)

> **navigationProfile**: (`actor`, `options`) => [`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

Create an actor-aware navigation profile.

#### Parameters

[Section titled “Parameters”](#parameters-4)

##### actor

[Section titled “actor”](#actor-2)

`string` | `Entity`

##### options?

[Section titled “options?”](#options-3)

[`GameboardActorNavigationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactornavigationoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-5)

[`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/)

### neighborhood

[Section titled “neighborhood”](#neighborhood)

> **neighborhood**: (`center`, `options`) => [`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

Inspect a radius of tiles around a center.

#### Parameters

[Section titled “Parameters”](#parameters-5)

##### center

[Section titled “center”](#center)

[`GameboardNeighborhoodCenter`](/declarative-hex-worlds/reference/index/type-aliases/gameboardneighborhoodcenter/)

##### options?

[Section titled “options?”](#options-4)

[`GameboardNeighborhoodInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspectionoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-6)

[`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

### read

[Section titled “read”](#read)

> **read**: () => [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Read all registered actors.

#### Returns

[Section titled “Returns”](#returns-7)

[`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

### register

[Section titled “register”](#register)

> **register**: (`placement`, `options`) => `Entity`

Register an existing placement as an actor.

#### Parameters

[Section titled “Parameters”](#parameters-6)

##### placement

[Section titled “placement”](#placement)

`string` | `Entity`

##### options

[Section titled “options”](#options-5)

[`GameboardActorRegistrationOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorregistrationoptions/)

#### Returns

[Section titled “Returns”](#returns-8)

`Entity`

### select

[Section titled “select”](#select)

> **select**: (`options`) => [`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

Select actors with optional faction, team, tag, radius, and hostility filters.

#### Parameters

[Section titled “Parameters”](#parameters-7)

##### options?

[Section titled “options?”](#options-6)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-9)

[`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

### spawn

[Section titled “spawn”](#spawn)

> **spawn**: (`options`) => `Entity`

Spawn a placement and register it as an actor.

#### Parameters

[Section titled “Parameters”](#parameters-8)

##### options

[Section titled “options”](#options-7)

[`SpawnGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardactoroptions/)

#### Returns

[Section titled “Returns”](#returns-10)

`Entity`

### targets

[Section titled “targets”](#targets)

> **targets**: (`options`) => [`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/)

Select and path to candidate actor targets.

#### Parameters

[Section titled “Parameters”](#parameters-9)

##### options

[Section titled “options”](#options-8)

[`GameboardActorTargetingOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/)

#### Returns

[Section titled “Returns”](#returns-11)

[`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/)

### tile

[Section titled “tile”](#tile)

> **tile**: (`coordinates`, `options`) => [`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

Inspect one tile from an actor/gameplay perspective.

#### Parameters

[Section titled “Parameters”](#parameters-10)

##### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### options?

[Section titled “options?”](#options-9)

[`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-12)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

### update

[Section titled “update”](#update)

> **update**: (`actor`, `options`) => `Entity`

Update actor trait state while preserving omitted fields.

#### Parameters

[Section titled “Parameters”](#parameters-11)

##### actor

[Section titled “actor”](#actor-3)

`string` | `Entity`

##### options

[Section titled “options”](#options-10)

[`UpdateGameboardActorOptions`](/declarative-hex-worlds/reference/index/interfaces/updategameboardactoroptions/)

#### Returns

[Section titled “Returns”](#returns-13)

`Entity`

# useGameboardActorEntities

> **useGameboardActorEntities**(): readonly `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:909](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L909)

Query actor entities together with their origin placement state.

## Returns

[Section titled “Returns”](#returns)

readonly `Entity`\[]

# useGameboardActorSelection

> **useGameboardActorSelection**(`options?`): [`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:800](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L800)

Select actors by team, hostility, tags, kind, tile, or interaction state.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`GameboardActorSelectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselectionoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardActorSelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorselection/)

# useGameboardActorsForTile

> **useGameboardActorsForTile**(`coordinates`): readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:671](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L671)

Read actor snapshots whose placement origin is one tile.

Use this when hover panels, tile inspectors, collision probes, or ECS mirrors need actor kind, team, hostility, tags, and interaction flags for a single hex without filtering the whole actor list in component code.

## Parameters

[Section titled “Parameters”](#parameters)

### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

## Returns

[Section titled “Returns”](#returns)

readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

# useGameboardActorSnapshots

> **useGameboardActorSnapshots**(): readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:653](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L653)

Read joined actor and placement snapshots for React panels and UI state.

The returned records are the same actor snapshots used by runtime reads and external ECS interop, which keeps HUDs, targeting panels, and tests aligned.

## Returns

[Section titled “Returns”](#returns)

readonly [`GameboardActorSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardactorsnapshot/)\[]

# useGameboardActorTargetCommand

> **useGameboardActorTargetCommand**(`options`): [`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:830](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L830)

Plan the concrete command for one actor-target interaction.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/) | `undefined`

## Returns

[Section titled “Returns”](#returns)

[`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/) | `undefined`

# useGameboardActorTargets

> **useGameboardActorTargets**(`options`): [`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:815](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L815)

Compute legal interaction targets for one actor from React.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`GameboardActorTargetingOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingoptions/) | `undefined`

## Returns

[Section titled “Returns”](#returns)

[`GameboardActorTargetingReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetingreport/) | `undefined`

# useGameboardCommandActions

> **useGameboardCommandActions**(): `object`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:535](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L535)

Bind higher-level command actions shared by UI, AI, and test flows.

## Returns

[Section titled “Returns”](#returns)

### execute

[Section titled “execute”](#execute)

> **execute**: (`commandOrTarget`, `options`) => [`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

Execute a command with optional host-game handlers.

#### Parameters

[Section titled “Parameters”](#parameters)

##### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

##### options?

[Section titled “options?”](#options)

[`GameboardInteractionCommandExecutionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecutionoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-1)

[`GameboardInteractionCommandExecution`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandexecution/)

### plan

[Section titled “plan”](#plan)

> **plan**: (`target`, `options`) => [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

Plan a command from a renderer or gameplay target.

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### target

[Section titled “target”](#target)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/)

##### options?

[Section titled “options?”](#options-1)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-2)

[`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/)

### preview

[Section titled “preview”](#preview)

> **preview**: (`commandOrTarget`, `options`) => [`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

Preview a command without mutating state.

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-1)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

##### options?

[Section titled “options?”](#options-2)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-3)

[`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/)

### targetCommand

[Section titled “targetCommand”](#targetcommand)

> **targetCommand**: (`options`) => [`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

Select an actor target and plan a command against it.

#### Parameters

[Section titled “Parameters”](#parameters-3)

##### options

[Section titled “options”](#options-3)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

#### Returns

[Section titled “Returns”](#returns-4)

[`GameboardActorTargetCommandPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandplan/)

# useGameboardInteractionCommand

> **useGameboardInteractionCommand**(`target`, `options?`): [`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:725](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L725)

Plan the command that would be executed for a selected interaction target.

## Parameters

[Section titled “Parameters”](#parameters)

### target

[Section titled “target”](#target)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/) | `undefined`

### options?

[Section titled “options?”](#options)

[`GameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardInteractionCommand`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommand/) | `undefined`

# useGameboardInteractionCommandPreview

> **useGameboardInteractionCommandPreview**(`commandOrTarget`, `options?`): [`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:745](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L745)

Preview an interaction command or target for HUD affordances and tests.

## Parameters

[Section titled “Parameters”](#parameters)

### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/) | `undefined`

### options?

[Section titled “options?”](#options)

[`GameboardInteractionCommandPreviewOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreviewoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardInteractionCommandPreview`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractioncommandpreview/) | `undefined`

# useGameboardInteractionTarget

> **useGameboardInteractionTarget**(`target`, `options?`): [`GameboardInteractionTargetReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetreport/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:705](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L705)

Inspect one interaction target from React without dispatching a command.

## Parameters

[Section titled “Parameters”](#parameters)

### target

[Section titled “target”](#target)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/) | `undefined`

### options?

[Section titled “options?”](#options)

[`GameboardInteractionTargetOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardInteractionTargetReport`](/declarative-hex-worlds/reference/index/interfaces/gameboardinteractiontargetreport/) | `undefined`

# useGameboardLayoutFillAnalysis

> **useGameboardLayoutFillAnalysis**(`options`): [`GameboardLayoutFillAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillanalysis/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1188](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1188)

Analyze seeded layout fill rules against the current projected board.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`GameboardLayoutFillOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfilloptions/) | `undefined`

## Returns

[Section titled “Returns”](#returns)

[`GameboardLayoutFillAnalysis`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillanalysis/) | `undefined`

# useGameboardLayoutPlacements

> **useGameboardLayoutPlacements**(`options`): readonly [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1202](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1202)

Preview layout placement options for the current projected board without spawning entities.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`GameboardLayoutPlacementOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutplacementoptions/) | `undefined`

## Returns

[Section titled “Returns”](#returns)

readonly [`SpawnGameboardPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardplacementoptions/)\[]

# useGameboardLayoutSiteInspection

> **useGameboardLayoutSiteInspection**(`options?`): [`GameboardLayoutSiteInspection`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutsiteinspection/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1175](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1175)

Inspect layout sites for the current projected board without mutating Koota state.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`InspectGameboardLayoutSitesOptions`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/inspectgameboardlayoutsitesoptions/) = `DEFAULT_LAYOUT_SITE_INSPECTION_OPTIONS`

## Returns

[Section titled “Returns”](#returns)

[`GameboardLayoutSiteInspection`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutsiteinspection/) | `undefined`

# useGameboardMovementActions

> **useGameboardMovementActions**(): `object`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:503](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L503)

Bind movement actions for starting, advancing, and completing placement paths.

## Returns

[Section titled “Returns”](#returns)

### advance

[Section titled “advance”](#advance)

> **advance**: (`placement`, `options`) => [`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)

Advance one placement along its requested path.

#### Parameters

[Section titled “Parameters”](#parameters)

##### placement

[Section titled “placement”](#placement)

`string` | `Entity`

##### options?

[Section titled “options?”](#options)

[`AdvanceGameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardmovementoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-1)

[`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)

### clear

[Section titled “clear”](#clear)

> **clear**: (`placement`) => `Entity`

Clear active movement path state for a placement.

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### placement

[Section titled “placement”](#placement-1)

`string` | `Entity`

#### Returns

[Section titled “Returns”](#returns-2)

`Entity`

### reachable

[Section titled “reachable”](#reachable)

> **reachable**: (`placement`, `options`) => [`GameboardReachableTile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardreachabletile/)\[]

Return tiles reachable by one movement agent.

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### placement

[Section titled “placement”](#placement-2)

`string` | `Entity`

##### options?

[Section titled “options?”](#options-1)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-3)

[`GameboardReachableTile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardreachabletile/)\[]

### requestMove

[Section titled “requestMove”](#requestmove)

> **requestMove**: (`placement`, `destination`, `options`) => [`GameboardMovementRequestResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementrequestresult/)

Request movement to a destination.

#### Parameters

[Section titled “Parameters”](#parameters-3)

##### placement

[Section titled “placement”](#placement-3)

`string` | `Entity`

##### destination

[Section titled “destination”](#destination)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

##### options?

[Section titled “options?”](#options-2)

[`GameboardMovementPathRequestOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementpathrequestoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-4)

[`GameboardMovementRequestResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementrequestresult/)

### resetBudget

[Section titled “resetBudget”](#resetbudget)

> **resetBudget**: (`placement?`, `options`) => readonly `Entity`\[]

Reset movement budget for one or all movement agents.

#### Parameters

[Section titled “Parameters”](#parameters-4)

##### placement?

[Section titled “placement?”](#placement-4)

`string` | `Entity`

##### options?

[Section titled “options?”](#options-3)

[`GameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-5)

readonly `Entity`\[]

### runSystem

[Section titled “runSystem”](#runsystem)

> **runSystem**: (`options`) => [`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)\[]

Advance all active movement agents.

#### Parameters

[Section titled “Parameters”](#parameters-5)

##### options?

[Section titled “options?”](#options-4)

[`AdvanceGameboardMovementOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardmovementoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-6)

[`GameboardMovementAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardmovementadvanceresult/)\[]

### setAgent

[Section titled “setAgent”](#setagent)

> **setAgent**: (`placement`, `options`) => `Entity`

Add or update a movement agent on a placement.

#### Parameters

[Section titled “Parameters”](#parameters-6)

##### placement

[Section titled “placement”](#placement-5)

`string` | `Entity`

##### options?

[Section titled “options?”](#options-5)

[`SetGameboardMovementAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardmovementagentoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-7)

`Entity`

# useGameboardNavigation

> **useGameboardNavigation**(`profile?`): [`GameboardNavigation`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigation/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1122](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1122)

Build pathfinding helpers from the current projected board.

## Parameters

[Section titled “Parameters”](#parameters)

### profile?

[Section titled “profile?”](#profile)

[`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/) = `DEFAULT_NAVIGATION_PROFILE_OPTIONS`

## Returns

[Section titled “Returns”](#returns)

[`GameboardNavigation`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigation/) | `undefined`

# useGameboardNeighborhoodInspection

> **useGameboardNeighborhoodInspection**(`center`, `options?`): [`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:784](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L784)

Inspect a tile neighborhood for overlays, local AI decisions, and debug UI.

## Parameters

[Section titled “Parameters”](#parameters)

### center

[Section titled “center”](#center)

[`GameboardNeighborhoodCenter`](/declarative-hex-worlds/reference/index/type-aliases/gameboardneighborhoodcenter/)

### options?

[Section titled “options?”](#options)

[`GameboardNeighborhoodInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspectionoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardNeighborhoodInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardneighborhoodinspection/)

# useGameboardOccupancyIndex

> **useGameboardOccupancyIndex**(`profile?`): [`GameboardOccupancyIndex`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardoccupancyindex/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1109](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1109)

Build a navigation occupancy index from the current projected board.

## Parameters

[Section titled “Parameters”](#parameters)

### profile?

[Section titled “profile?”](#profile)

[`GameboardNavigationProfile`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardnavigationprofile/) = `DEFAULT_NAVIGATION_PROFILE_OPTIONS`

## Returns

[Section titled “Returns”](#returns)

[`GameboardOccupancyIndex`](/declarative-hex-worlds/reference/gameboard/navigation/interfaces/gameboardoccupancyindex/) | `undefined`

# useGameboardPatrolActions

> **useGameboardPatrolActions**(): `object`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:527](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L527)

Bind patrol actions for attaching patrol agents and route state.

## Returns

[Section titled “Returns”](#returns)

### advance

[Section titled “advance”](#advance)

> **advance**: (`placement`, `options`) => [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)

Advance one patrol agent.

#### Parameters

[Section titled “Parameters”](#parameters)

##### placement

[Section titled “placement”](#placement)

`string` | `Entity`

##### options?

[Section titled “options?”](#options)

[`AdvanceGameboardPatrolOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardpatroloptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-1)

[`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)

### clear

[Section titled “clear”](#clear)

> **clear**: (`placement`) => `Entity`

Remove patrol traits from a placement.

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### placement

[Section titled “placement”](#placement-1)

`string` | `Entity`

#### Returns

[Section titled “Returns”](#returns-2)

`Entity`

### read

[Section titled “read”](#read)

> **read**: () => [`GameboardPatrolSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/)\[]

Read all patrol snapshots.

#### Returns

[Section titled “Returns”](#returns-3)

[`GameboardPatrolSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatrolsnapshot/)\[]

### run

[Section titled “run”](#run)

> **run**: (`options`) => [`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)\[]

Advance every patrol agent in the world.

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### options?

[Section titled “options?”](#options-1)

[`AdvanceGameboardPatrolOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardpatroloptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-4)

[`GameboardPatrolAdvanceResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardpatroladvanceresult/)\[]

### set

[Section titled “set”](#set)

> **set**: (`placement`, `options`) => `Entity`

Attach or replace a patrol agent.

#### Parameters

[Section titled “Parameters”](#parameters-3)

##### placement

[Section titled “placement”](#placement-2)

`string` | `Entity`

##### options

[Section titled “options”](#options-2)

[`SetGameboardPatrolAgentOptions`](/declarative-hex-worlds/reference/index/interfaces/setgameboardpatrolagentoptions/)

#### Returns

[Section titled “Returns”](#returns-5)

`Entity`

# useGameboardPatrolAgent

> **useGameboardPatrolAgent**(`entity`): { `active`: `boolean`; `currentWaypointIndex`: `number`; `loop`: `boolean`; `pauseTicks`: `number`; `roundsCompleted`: `number`; `routeId`: `string`; `segmentCosts`: `number`\[]; `targetWaypointIndex`: `number`; `waitTicksRemaining`: `number`; `waypointKeys`: `string`\[]; } | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1044](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1044)

Read patrol agent configuration for one actor entity.

## Parameters

[Section titled “Parameters”](#parameters)

### entity

[Section titled “entity”](#entity)

`Entity` | `null` | `undefined`

## Returns

[Section titled “Returns”](#returns)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `active`: `boolean`; `currentWaypointIndex`: `number`; `loop`: `boolean`; `pauseTicks`: `number`; `roundsCompleted`: `number`; `routeId`: `string`; `segmentCosts`: `number`\[]; `targetWaypointIndex`: `number`; `waitTicksRemaining`: `number`; `waypointKeys`: `string`\[]; }

#### active

[Section titled “active”](#active)

> **active**: `boolean` = `true`

Whether the patrol agent is active.

#### currentWaypointIndex

[Section titled “currentWaypointIndex”](#currentwaypointindex)

> **currentWaypointIndex**: `number` = `0`

Current waypoint index.

#### loop

[Section titled “loop”](#loop)

> **loop**: `boolean` = `true`

Whether the route loops back to the first waypoint.

#### pauseTicks

[Section titled “pauseTicks”](#pauseticks)

> **pauseTicks**: `number` = `0`

Ticks to wait after reaching each waypoint.

#### roundsCompleted

[Section titled “roundsCompleted”](#roundscompleted)

> **roundsCompleted**: `number` = `0`

Number of completed route rounds.

#### routeId

[Section titled “routeId”](#routeid)

> **routeId**: `string` = `''`

Route id followed by this patrol.

#### segmentCosts

[Section titled “segmentCosts”](#segmentcosts)

> **segmentCosts**: `number`\[]

Optional movement budget per route segment.

#### targetWaypointIndex

[Section titled “targetWaypointIndex”](#targetwaypointindex)

> **targetWaypointIndex**: `number` = `-1`

Target waypoint index for an in-flight segment.

#### waitTicksRemaining

[Section titled “waitTicksRemaining”](#waitticksremaining)

> **waitTicksRemaining**: `number` = `0`

Remaining wait ticks before the next segment.

#### waypointKeys

[Section titled “waypointKeys”](#waypointkeys)

> **waypointKeys**: `string`\[]

Ordered route waypoint tile keys.

***

`undefined`

# useGameboardPatrolAgentEntities

> **useGameboardPatrolAgentEntities**(): readonly `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:923](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L923)

Query actors that have patrol agent state attached.

## Returns

[Section titled “Returns”](#returns)

readonly `Entity`\[]

# useGameboardPatrolRoute

> **useGameboardPatrolRoute**(`options`): `GameboardPatrolRoutePlan` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1148](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1148)

Plan one patrol route from the current projected board.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

`GameboardPatrolRouteOptions` | `undefined`

## Returns

[Section titled “Returns”](#returns)

`GameboardPatrolRoutePlan` | `undefined`

# useGameboardPatrolRoutes

> **useGameboardPatrolRoutes**(`options`): `GameboardPatrolRouteSet` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1161](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1161)

Plan multiple patrol routes from the current projected board.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

`GameboardPatrolRouteSetOptions` | `undefined`

## Returns

[Section titled “Returns”](#returns)

`GameboardPatrolRouteSet` | `undefined`

# useGameboardPatrolState

> **useGameboardPatrolState**(`entity`): { `lastPathKeys`: `string`\[]; `reason`: `string` | `undefined`; `status`: [`GameboardPatrolStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardpatrolstatus/); `targetKey`: `string`; } | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1053](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1053)

Read live patrol route progress for one actor entity.

## Parameters

[Section titled “Parameters”](#parameters)

### entity

[Section titled “entity”](#entity)

`Entity` | `null` | `undefined`

## Returns

[Section titled “Returns”](#returns)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `lastPathKeys`: `string`\[]; `reason`: `string` | `undefined`; `status`: [`GameboardPatrolStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardpatrolstatus/); `targetKey`: `string`; }

#### lastPathKeys

[Section titled “lastPathKeys”](#lastpathkeys)

> **lastPathKeys**: `string`\[]

Last requested movement path tile keys.

#### reason

[Section titled “reason”](#reason)

> **reason**: `string` | `undefined`

Blocked or paused reason.

#### status

[Section titled “status”](#status)

> **status**: [`GameboardPatrolStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardpatrolstatus/)

Current patrol status.

#### targetKey

[Section titled “targetKey”](#targetkey)

> **targetKey**: `string` = `''`

Current target waypoint tile key.

***

`undefined`

# useGameboardPieceFillInspection

> **useGameboardPieceFillInspection**(`registry`, `fills`, `options?`): [`SeededGameboardPieceFillInspection`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefillinspection/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1257](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1257)

Dry-run selected registry pieces as seeded layout fills for the current projected board.

## Parameters

[Section titled “Parameters”](#parameters)

### registry

[Section titled “registry”](#registry)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/) | `undefined`

### fills

[Section titled “fills”](#fills)

readonly [`SeededGameboardPieceFillOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefilloptions/)\[] | `undefined`

### options?

[Section titled “options?”](#options)

[`InspectSeededGameboardPieceFillsOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectseededgameboardpiecefillsoptions/) = `DEFAULT_PIECE_FILL_INSPECTION_OPTIONS`

## Returns

[Section titled “Returns”](#returns)

[`SeededGameboardPieceFillInspection`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefillinspection/) | `undefined`

# useGameboardPiecePlacementInspection

> **useGameboardPiecePlacementInspection**(`piece`, `options?`): [`GameboardPiecePlacementInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementinspection/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1242](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1242)

Inspect one declared piece against the current projected board.

## Parameters

[Section titled “Parameters”](#parameters)

### piece

[Section titled “piece”](#piece)

[`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/) | `undefined`

### options?

[Section titled “options?”](#options)

[`GameboardPiecePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementoptions/) = `DEFAULT_PIECE_PLACEMENT_OPTIONS`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPiecePlacementInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceplacementinspection/) | `undefined`

# useGameboardPieceRegistryAnalysis

> **useGameboardPieceRegistryAnalysis**(`registry`, `options?`): [`GameboardPieceRegistryAnalysis`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryanalysis/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1216](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1216)

Analyze a piece registry for React editor panels and pack setup screens.

## Parameters

[Section titled “Parameters”](#parameters)

### registry

[Section titled “registry”](#registry)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/) | `undefined`

### options?

[Section titled “options?”](#options)

[`AnalyzeGameboardPieceRegistryOptions`](/declarative-hex-worlds/reference/index/interfaces/analyzegameboardpieceregistryoptions/) = `DEFAULT_PIECE_REGISTRY_ANALYSIS_OPTIONS`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPieceRegistryAnalysis`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryanalysis/) | `undefined`

# useGameboardPieceSelection

> **useGameboardPieceSelection**(`registry`, `selection?`): readonly [`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1229](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1229)

Select registered pieces by role, source, tag, asset id, or local-only state.

## Parameters

[Section titled “Parameters”](#parameters)

### registry

[Section titled “registry”](#registry)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/) | `undefined`

### selection?

[Section titled “selection?”](#selection)

[`GameboardPieceRegistrySelection`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistryselection/) = `DEFAULT_PIECE_REGISTRY_SELECTION`

## Returns

[Section titled “Returns”](#returns)

readonly [`GameboardPieceDeclaration`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclaration/)\[]

# useGameboardPieceSourceUrlMap

> **useGameboardPieceSourceUrlMap**(`registry`, `options?`): `Readonly`<`Record`<`string`, `string`>>

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1275](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1275)

Build renderer URL overrides from registered piece source metadata.

## Parameters

[Section titled “Parameters”](#parameters)

### registry

[Section titled “registry”](#registry)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/) | `undefined`

### options?

[Section titled “options?”](#options)

[`GameboardPieceSourceUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecesourceurloptions/) = `DEFAULT_PIECE_SOURCE_URL_OPTIONS`

## Returns

[Section titled “Returns”](#returns)

`Readonly`<`Record`<`string`, `string`>>

# useGameboardPlacementEntities

> **useGameboardPlacementEntities**(): readonly `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:867](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L867)

Query all entities that represent board placements on top of tiles.

## Returns

[Section titled “Returns”](#returns)

readonly `Entity`\[]

# useGameboardPlacementOccupancy

> **useGameboardPlacementOccupancy**(): readonly [`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1331](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1331)

Read placement occupancy snapshots for every occupied tile.

## Returns

[Section titled “Returns”](#returns)

readonly [`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

# useGameboardPlacementOccupancyInspection

> **useGameboardPlacementOccupancyInspection**(`options`): [`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1347](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1347)

Inspect whether a proposed placement can occupy the current board.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`InspectGameboardPlacementOccupancyOptions`](/declarative-hex-worlds/reference/index/interfaces/inspectgameboardplacementoccupancyoptions/) | `undefined`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlacementOccupancyInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementoccupancyinspection/) | `undefined`

# useGameboardPlacementSnapshots

> **useGameboardPlacementSnapshots**(): readonly `object`\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:636](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L636)

Read serializable placement snapshots for React panels and external stores.

The hook subscribes to placement trait and relation changes, including in place movement updates where the set of placement entities does not change.

## Returns

[Section titled “Returns”](#returns)

readonly `object`\[]

# useGameboardQuest

> **useGameboardQuest**(`entity`): { `activeObjectiveIndex`: `number`; `metadata`: `Record`<`string`, [`GameboardQuestMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestmetadatavalue/)>; `objectives`: [`GameboardQuestObjective`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestobjective/)\[]; `progress`: [`GameboardQuestObjectiveProgress`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectiveprogress/)\[]; `questId`: `string`; `schemaVersion`: `string`; `status`: [`GameboardQuestStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardqueststatus/); `title`: `string`; } | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1035](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1035)

Read quest metadata and progress for one quest entity.

## Parameters

[Section titled “Parameters”](#parameters)

### entity

[Section titled “entity”](#entity)

`Entity` | `null` | `undefined`

## Returns

[Section titled “Returns”](#returns)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `activeObjectiveIndex`: `number`; `metadata`: `Record`<`string`, [`GameboardQuestMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestmetadatavalue/)>; `objectives`: [`GameboardQuestObjective`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestobjective/)\[]; `progress`: [`GameboardQuestObjectiveProgress`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectiveprogress/)\[]; `questId`: `string`; `schemaVersion`: `string`; `status`: [`GameboardQuestStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardqueststatus/); `title`: `string`; }

#### activeObjectiveIndex

[Section titled “activeObjectiveIndex”](#activeobjectiveindex)

> **activeObjectiveIndex**: `number` = `0`

Index of the active objective in `objectives`.

#### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Record`<`string`, [`GameboardQuestMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestmetadatavalue/)>

Serializable quest metadata.

#### objectives

[Section titled “objectives”](#objectives)

> **objectives**: [`GameboardQuestObjective`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestobjective/)\[]

Ordered objective definitions.

#### progress

[Section titled “progress”](#progress)

> **progress**: [`GameboardQuestObjectiveProgress`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectiveprogress/)\[]

Objective progress records.

#### questId

[Section titled “questId”](#questid)

> **questId**: `string` = `''`

Stable quest id.

#### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> **schemaVersion**: `string` = `GAMEBOARD_QUEST_SCHEMA_VERSION`

Quest schema version.

#### status

[Section titled “status”](#status)

> **status**: [`GameboardQuestStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardqueststatus/)

Runtime quest lifecycle status.

#### title

[Section titled “title”](#title)

> **title**: `string` = `''`

Quest display title.

***

`undefined`

# useGameboardQuestActions

> **useGameboardQuestActions**(): `object`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:519](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L519)

Bind quest actions for spawning objectives and updating quest progress.

## Returns

[Section titled “Returns”](#returns)

### advance

[Section titled “advance”](#advance)

> **advance**: (`quest`, `options`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

Advance one quest entity.

#### Parameters

[Section titled “Parameters”](#parameters)

##### quest

[Section titled “quest”](#quest)

`string` | `Entity`

##### options?

[Section titled “options?”](#options)

[`AdvanceGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardquestoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-1)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)

### advanceAll

[Section titled “advanceAll”](#advanceall)

> **advanceAll**: (`options`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Advance every quest entity.

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### options?

[Section titled “options?”](#options-1)

[`AdvanceGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/advancegameboardquestoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-2)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

### find

[Section titled “find”](#find)

> **find**: (`quest`) => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/) | `undefined`

Find one quest snapshot.

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### quest

[Section titled “quest”](#quest-1)

`string` | `Entity`

#### Returns

[Section titled “Returns”](#returns-3)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/) | `undefined`

### read

[Section titled “read”](#read)

> **read**: () => [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Read all quest snapshots.

#### Returns

[Section titled “Returns”](#returns-4)

[`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

### spawn

[Section titled “spawn”](#spawn)

> **spawn**: (`definition`, `options`) => `Entity`

Spawn a quest entity.

#### Parameters

[Section titled “Parameters”](#parameters-3)

##### definition

[Section titled “definition”](#definition)

[`GameboardQuestDefinition`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestdefinition/)

##### options?

[Section titled “options?”](#options-2)

[`SpawnGameboardQuestOptions`](/declarative-hex-worlds/reference/index/interfaces/spawngameboardquestoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-5)

`Entity`

# useGameboardQuestEntities

> **useGameboardQuestEntities**(): readonly `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:916](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L916)

Query all quest entities in the current board world.

## Returns

[Section titled “Returns”](#returns)

readonly `Entity`\[]

# useGameboardQuestSnapshots

> **useGameboardQuestSnapshots**(): readonly [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:691](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L691)

Read quest snapshots for React quest logs, HUDs, and integration mirrors.

The hook rerenders when quest state changes or when related actor movement changes may complete reach, interaction, collision, or defeat objectives.

## Returns

[Section titled “Returns”](#returns)

readonly [`GameboardQuestSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestsnapshot/)\[]

# useGameboardRuleViolations

> **useGameboardRuleViolations**(`config?`): readonly [`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1389](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1389)

Validate the live Koota world against gameboard rule configuration.

## Parameters

[Section titled “Parameters”](#parameters)

### config?

[Section titled “config?”](#config)

[`GameboardRuleConfig`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleconfig/) = `DEFAULT_RULE_CONFIG`

## Returns

[Section titled “Returns”](#returns)

readonly [`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

# useGameboardRuntime

> **useGameboardRuntime**<`TRuntime`>(): `TRuntime`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:556](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L556)

Return the runtime facade associated with the current React provider.

If no runtime provider was mounted, the hook binds a facade to the current Koota world. Use `GameboardRuntimeProvider` or the plan/recipe/scenario providers when components need runtime-specific helpers such as source URL maps, scenario indexes, or saved recipe registries.

## Type Parameters

[Section titled “Type Parameters”](#type-parameters)

### TRuntime

[Section titled “TRuntime”](#truntime)

`TRuntime` *extends* [`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/) = [`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/)

## Returns

[Section titled “Returns”](#returns)

`TRuntime`

# useGameboardRuntimeSnapshot

> **useGameboardRuntimeSnapshot**(`options?`): [`GameboardRuntimeSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimesnapshot/)

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:618](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L618)

Read the current runtime snapshot and rerender when gameboard traits, relations, actor state, movement state, patrol state, or quest state changes.

This is the React equivalent of `runtime.snapshot()`. Use it for HUDs, inspectors, test probes, and render adapters that want a serializable view of live board state instead of raw Koota trait access.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`GameboardRuntimeSnapshotOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimesnapshotoptions/) = `DEFAULT_RUNTIME_SNAPSHOT_OPTIONS`

## Returns

[Section titled “Returns”](#returns)

[`GameboardRuntimeSnapshot`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntimesnapshot/)

# useGameboardSpawnLocations

> **useGameboardSpawnLocations**(`options`): readonly [`SpawnLocation`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocation/)\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1135](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1135)

Select legal spawn locations from the current projected board.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

`GameboardSpawnLocationOptions` | `undefined`

## Returns

[Section titled “Returns”](#returns)

readonly [`SpawnLocation`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/spawnlocation/)\[]

# useGameboardState

> **useGameboardState**(): { `placementCount`: `number`; `schemaVersion`: `string`; `seed`: `string`; `shape`: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/); `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileCount`: `number`; } | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:488](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L488)

Read the root board state trait from the current Koota world.

## Returns

[Section titled “Returns”](#returns)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `placementCount`: `number`; `schemaVersion`: `string`; `seed`: `string`; `shape`: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/); `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileCount`: `number`; }

#### placementCount

[Section titled “placementCount”](#placementcount)

> **placementCount**: `number` = `0`

Number of placement entities loaded into the world.

#### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> **schemaVersion**: `string` = `GAMEBOARD_SCHEMA_VERSION`

Manifest/schema version used to generate the loaded board.

#### seed

[Section titled “seed”](#seed)

> **seed**: `string` = `''`

Seed used by deterministic layout or simulation helpers.

#### shape

[Section titled “shape”](#shape)

> **shape**: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

Board shape descriptor, such as rectangle or hexagon.

#### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Active KayKit texture set for generated terrain and placements.

#### tileCount

[Section titled “tileCount”](#tilecount)

> **tileCount**: `number` = `0`

Number of tile entities loaded into the world.

***

`undefined`

# useGameboardSystemActions

> **useGameboardSystemActions**(): `object`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:543](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L543)

Bind system tick actions for running movement, patrol, and quest systems.

## Returns

[Section titled “Returns”](#returns)

### dispatchActorTargetCommand

[Section titled “dispatchActorTargetCommand”](#dispatchactortargetcommand)

> **dispatchActorTargetCommand**: (`options`, `commandOptions`) => [`DispatchGameboardActorTargetCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardactortargetcommandresult/)

Select an actor target, then execute its planned command.

#### Parameters

[Section titled “Parameters”](#parameters)

##### options

[Section titled “options”](#options)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

##### commandOptions?

[Section titled “commandOptions?”](#commandoptions)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-1)

[`DispatchGameboardActorTargetCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardactortargetcommandresult/)

### dispatchCommand

[Section titled “dispatchCommand”](#dispatchcommand)

> **dispatchCommand**: (`commandOrTarget`, `options`) => [`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

Execute one command and emit dispatch event records.

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

##### options?

[Section titled “options?”](#options-1)

[`DispatchGameboardInteractionCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-2)

[`DispatchGameboardInteractionCommandResult`](/declarative-hex-worlds/reference/index/interfaces/dispatchgameboardinteractioncommandresult/)

### interact

[Section titled “interact”](#interact)

> **interact**: (`commandOrTarget`, `options`) => [`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/)

Dispatch a command and optionally tick systems.

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### commandOrTarget

[Section titled “commandOrTarget”](#commandortarget-1)

[`GameboardInteractionCommandInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractioncommandinput/)

##### options?

[Section titled “options?”](#options-2)

[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-3)

[`RunGameboardInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionresult/)

### interactActorTarget

[Section titled “interactActorTarget”](#interactactortarget)

> **interactActorTarget**: (`options`, `interactionOptions`) => [`RunGameboardActorTargetInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardactortargetinteractionresult/)

Target an actor, dispatch the command, and optionally tick systems.

#### Parameters

[Section titled “Parameters”](#parameters-3)

##### options

[Section titled “options”](#options-3)

[`GameboardActorTargetCommandOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardactortargetcommandoptions/)

##### interactionOptions?

[Section titled “interactionOptions?”](#interactionoptions)

[`RunGameboardInteractionOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardinteractionoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-4)

[`RunGameboardActorTargetInteractionResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardactortargetinteractionresult/)

### run

[Section titled “run”](#run)

> **run**: (`options`) => [`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

Run enabled patrol, movement, and quest systems for one tick.

#### Parameters

[Section titled “Parameters”](#parameters-4)

##### options?

[Section titled “options?”](#options-4)

[`RunGameboardSystemsOptions`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsoptions/) = `{}`

#### Returns

[Section titled “Returns”](#returns-5)

[`RunGameboardSystemsResult`](/declarative-hex-worlds/reference/index/interfaces/rungameboardsystemsresult/)

# useGameboardTileEntities

> **useGameboardTileEntities**(): readonly `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:845](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L845)

Query all entities that represent canonical gameboard tiles.

## Returns

[Section titled “Returns”](#returns)

readonly `Entity`\[]

# useGameboardTileInspection

> **useGameboardTileInspection**(`coordinates`, `options?`): [`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:767](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L767)

Inspect terrain, connectivity, occupancy, and actor state for one tile.

## Parameters

[Section titled “Parameters”](#parameters)

### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### options?

[Section titled “options?”](#options)

[`GameboardTileInspectionOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspectionoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardTileInspection`](/declarative-hex-worlds/reference/index/interfaces/gameboardtileinspection/)

# useGameboardWorld

> **useGameboardWorld**(): `World`

Defined in: node\_modules/.pnpm/koota\@0.6.6\_@<types+react@19.2.17_react>@19.2.7/node\_modules/koota/dist/react.d.ts:31

## Returns

[Section titled “Returns”](#returns)

`World`

# useHarborPlacementEntities

> **useHarborPlacementEntities**(): readonly `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:888](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L888)

Query placement entities tagged as harbors or ports.

## Returns

[Section titled “Returns”](#returns)

readonly `Entity`\[]

# useMovementAgent

> **useMovementAgent**(`entity`): { `movementBudget`: `number`; `profileId`: [`GameboardMovementProfileId`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementprofileid/); `remainingMovement`: `number`; } | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1008](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1008)

Read movement agent metadata for one moving placement.

## Parameters

[Section titled “Parameters”](#parameters)

### entity

[Section titled “entity”](#entity)

`Entity` | `null` | `undefined`

## Returns

[Section titled “Returns”](#returns)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `movementBudget`: `number`; `profileId`: [`GameboardMovementProfileId`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementprofileid/); `remainingMovement`: `number`; }

#### movementBudget

[Section titled “movementBudget”](#movementbudget)

> **movementBudget**: `number` = `6`

Maximum movement budget.

#### profileId

[Section titled “profileId”](#profileid)

> **profileId**: [`GameboardMovementProfileId`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementprofileid/)

Movement profile id used by this agent.

#### remainingMovement

[Section titled “remainingMovement”](#remainingmovement)

> **remainingMovement**: `number` = `6`

Remaining movement budget in the current cycle.

***

`undefined`

# useMovementPathState

> **useMovementPathState**(`entity`): { `cost`: `number`; `destinationKey`: `string`; `nextIndex`: `number`; `pathKeys`: `string`\[]; `reason`: `string` | `undefined`; `spentCost`: `number`; `status`: [`GameboardMovementStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementstatus/); `visited`: `number`; } | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1017](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1017)

Read current path-following state for one moving placement.

## Parameters

[Section titled “Parameters”](#parameters)

### entity

[Section titled “entity”](#entity)

`Entity` | `null` | `undefined`

## Returns

[Section titled “Returns”](#returns)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `cost`: `number`; `destinationKey`: `string`; `nextIndex`: `number`; `pathKeys`: `string`\[]; `reason`: `string` | `undefined`; `spentCost`: `number`; `status`: [`GameboardMovementStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementstatus/); `visited`: `number`; }

#### cost

[Section titled “cost”](#cost)

> **cost**: `number` = `0`

Total planned path cost.

#### destinationKey

[Section titled “destinationKey”](#destinationkey)

> **destinationKey**: `string` = `''`

Destination tile key for the current request.

#### nextIndex

[Section titled “nextIndex”](#nextindex)

> **nextIndex**: `number` = `0`

Next path index to advance to.

#### pathKeys

[Section titled “pathKeys”](#pathkeys)

> **pathKeys**: `string`\[]

Planned path tile keys.

#### reason

[Section titled “reason”](#reason)

> **reason**: `string` | `undefined`

Blocked or out-of-range reason.

#### spentCost

[Section titled “spentCost”](#spentcost)

> **spentCost**: `number` = `0`

Cost spent so far.

#### status

[Section titled “status”](#status)

> **status**: [`GameboardMovementStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementstatus/)

Current movement status.

#### visited

[Section titled “visited”](#visited)

> **visited**: `number` = `0`

Number of pathfinder nodes visited for the request.

***

`undefined`

# useMovingPlacementEntities

> **useMovingPlacementEntities**(): readonly `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:902](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L902)

Query placements currently controlled by movement state.

## Returns

[Section titled “Returns”](#returns)

readonly `Entity`\[]

# useOriginPlacementEntitiesForTile

> **useOriginPlacementEntitiesForTile**(`coordinates`): readonly `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1374](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1374)

Read placements whose origin tile is exactly the requested tile.

## Parameters

[Section titled “Parameters”](#parameters)

### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

## Returns

[Section titled “Returns”](#returns)

readonly `Entity`\[]

# usePlacementEntitiesForTile

> **usePlacementEntitiesForTile**(`coordinates`): readonly `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1297](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1297)

Read every placement that occupies one tile, including multi-tile footprints.

## Parameters

[Section titled “Parameters”](#parameters)

### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

## Returns

[Section titled “Returns”](#returns)

readonly `Entity`\[]

# usePlacementOccupancyForTile

> **usePlacementOccupancyForTile**(`coordinates`): readonly [`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1312](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1312)

Read placement occupancy snapshots for one tile key or coordinate.

## Parameters

[Section titled “Parameters”](#parameters)

### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

## Returns

[Section titled “Returns”](#returns)

readonly [`PlacementOccupancySnapshot`](/declarative-hex-worlds/reference/index/interfaces/placementoccupancysnapshot/)\[]

# usePlacementsByClassifier

> **usePlacementsByClassifier**(`tag`): readonly [`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1097](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1097)

Live placements carrying a gameplay classifier tag (RFC0-TAG). Reactively filters the projected plan’s placements by classifier metadata — re-runs when the board changes. e.g. `usePlacementsByClassifier('enemy')` drives an enemy overlay.

## Parameters

[Section titled “Parameters”](#parameters)

### tag

[Section titled “tag”](#tag)

[`ClassifierTag`](/declarative-hex-worlds/reference/index/type-aliases/classifiertag/)

## Returns

[Section titled “Returns”](#returns)

readonly [`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)\[]

# usePlacementState

> **usePlacementState**(`entity`): { `assetId`: `string`; `coordinates`: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; } | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:999](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L999)

Read placement state for one placement or actor entity.

## Parameters

[Section titled “Parameters”](#parameters)

### entity

[Section titled “entity”](#entity)

`Entity` | `null` | `undefined`

## Returns

[Section titled “Returns”](#returns)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `assetId`: `string`; `coordinates`: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }

#### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string` = `''`

Manifest or external registry asset id.

#### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Axial coordinates of the origin tile.

#### elevation

[Section titled “elevation”](#elevation)

> **elevation**: `number` = `0`

Base tile elevation where the placement was spawned.

#### elevationOffset

[Section titled “elevationOffset”](#elevationoffset)

> **elevationOffset**: `number` = `0`

Extra vertical offset above the tile elevation.

#### id

[Section titled “id”](#id)

> **id**: `string` = `''`

Stable placement id.

#### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Gameplay category for rules, selectors, and rendering.

#### layer

[Section titled “layer”](#layer)

> **layer**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Render and occupancy layer.

#### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Record`<`string`, `string` | `number` | `boolean` | `null`>

Serializable placement metadata for rules, ECS interop, and render hints.

#### order

[Section titled “order”](#order)

> **order**: `number` = `0`

Stable sort order used by renderers and snapshots.

#### position

[Section titled “position”](#position)

> **position**: [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/)

World-space placement anchor after elevation and local offsets.

#### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean` = `false`

Whether the placement depends on local-only EXTRA assets.

#### rotationRadians

[Section titled “rotationRadians”](#rotationradians)

> **rotationRadians**: `number` = `0`

Rotation in radians derived from `rotationSteps`.

#### rotationSteps

[Section titled “rotationSteps”](#rotationsteps)

> **rotationSteps**: `number` = `0`

Clockwise 60-degree rotation steps.

#### scale

[Section titled “scale”](#scale)

> **scale**: `number` = `1`

Uniform render scale.

#### stackIndex

[Section titled “stackIndex”](#stackindex)

> **stackIndex**: `number` | `undefined`

Optional stack index for layered terrain and vertical props.

#### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

KayKit texture set applied to this placement.

#### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string` = `''`

Origin tile key in `q,r` form.

***

`undefined`

# useProjectedGameboardPlan

> **useProjectedGameboardPlan**(`options?`): [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1062](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1062)

Project the live Koota world back into a serializable `GameboardPlan`.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`ProjectWorldOptions`](/declarative-hex-worlds/reference/coordinates/projection/interfaces/projectworldoptions/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/) | `undefined`

# useRiverPlacementEntities

> **useRiverPlacementEntities**(): readonly `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:881](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L881)

Query placement entities tagged as rivers.

## Returns

[Section titled “Returns”](#returns)

readonly `Entity`\[]

# useRoadPlacementEntities

> **useRoadPlacementEntities**(): readonly `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:874](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L874)

Query placement entities tagged as roads.

## Returns

[Section titled “Returns”](#returns)

readonly `Entity`\[]

# useStackedTerrainEntities

> **useStackedTerrainEntities**(): readonly `Entity`\[]

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:895](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L895)

Query terrain placements that participate in vertical stacking.

## Returns

[Section titled “Returns”](#returns)

readonly `Entity`\[]

# useTileConnectivity

> **useTileConnectivity**(`entity`): { `coastEdges`: `number`; `coastWaterless`: `boolean`; `riverCrossing`: `"A"` | `"B"` | `undefined`; `riverCurvy`: `boolean`; `riverEdges`: `number`; `riverWaterless`: `boolean`; `roadEdges`: `number`; `roadSlope`: `"high"` | `"low"` | `undefined`; } | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:967](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L967)

Read six-edge connectivity data for one tile entity.

## Parameters

[Section titled “Parameters”](#parameters)

### entity

[Section titled “entity”](#entity)

`Entity` | `null` | `undefined`

## Returns

[Section titled “Returns”](#returns)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `coastEdges`: `number`; `coastWaterless`: `boolean`; `riverCrossing`: `"A"` | `"B"` | `undefined`; `riverCurvy`: `boolean`; `riverEdges`: `number`; `riverWaterless`: `boolean`; `roadEdges`: `number`; `roadSlope`: `"high"` | `"low"` | `undefined`; }

#### coastEdges

[Section titled “coastEdges”](#coastedges)

> **coastEdges**: `number` = `0`

Six-edge bitmask for coast connectivity.

#### coastWaterless

[Section titled “coastWaterless”](#coastwaterless)

> **coastWaterless**: `boolean` = `false`

Whether this coast tile uses the waterless guide variant.

#### riverCrossing

[Section titled “riverCrossing”](#rivercrossing)

> **riverCrossing**: `"A"` | `"B"` | `undefined`

River crossing variant, when present.

#### riverCurvy

[Section titled “riverCurvy”](#rivercurvy)

> **riverCurvy**: `boolean` = `false`

Whether this river tile uses the curvy guide variant.

#### riverEdges

[Section titled “riverEdges”](#riveredges)

> **riverEdges**: `number` = `0`

Six-edge bitmask for river connectivity.

#### riverWaterless

[Section titled “riverWaterless”](#riverwaterless)

> **riverWaterless**: `boolean` = `false`

Whether this river tile uses the waterless guide variant.

#### roadEdges

[Section titled “roadEdges”](#roadedges)

> **roadEdges**: `number` = `0`

Six-edge bitmask for road connectivity.

#### roadSlope

[Section titled “roadSlope”](#roadslope)

> **roadSlope**: `"high"` | `"low"` | `undefined`

Road slope variant when a road changes elevation.

***

`undefined`

# useTileCoordinates

> **useTileCoordinates**(`entity`): { `key`: `string`; `q`: `number`; `r`: `number`; } | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:942](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L942)

Read axial coordinates for one tile entity.

## Parameters

[Section titled “Parameters”](#parameters)

### entity

[Section titled “entity”](#entity)

`Entity` | `null` | `undefined`

## Returns

[Section titled “Returns”](#returns)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `key`: `string`; `q`: `number`; `r`: `number`; }

#### key

[Section titled “key”](#key)

> **key**: `string` = `''`

Stable axial key in `q,r` form.

#### q

[Section titled “q”](#q)

> **q**: `number` = `0`

Axial q coordinate.

#### r

[Section titled “r”](#r)

> **r**: `number` = `0`

Axial r coordinate.

***

`undefined`

# useTileElevation

> **useTileElevation**(`entity`): { `baseAssetId`: `string`; `elevation`: `number`; `supportAssetId`: `string`; } | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:958](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L958)

Read base elevation data for one tile entity.

## Parameters

[Section titled “Parameters”](#parameters)

### entity

[Section titled “entity”](#entity)

`Entity` | `null` | `undefined`

## Returns

[Section titled “Returns”](#returns)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `baseAssetId`: `string`; `elevation`: `number`; `supportAssetId`: `string`; }

#### baseAssetId

[Section titled “baseAssetId”](#baseassetid)

> **baseAssetId**: `string` = `''`

Asset id for the visible tile top.

#### elevation

[Section titled “elevation”](#elevation)

> **elevation**: `number` = `0`

Stacked elevation level for the tile top.

#### supportAssetId

[Section titled “supportAssetId”](#supportassetid)

> **supportAssetId**: `string` = `''`

Optional asset id for the vertical support below elevated tiles.

***

`undefined`

# useTileEntity

> **useTileEntity**(`coordinates`): `Entity` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:1288](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L1288)

Find the tile entity for one axial coordinate or tile key.

## Parameters

[Section titled “Parameters”](#parameters)

### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

## Returns

[Section titled “Returns”](#returns)

`Entity` | `undefined`

# useTileRenderState

> **useTileRenderState**(`entity`): { `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; } | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:976](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L976)

Read render placement data for one tile entity.

## Parameters

[Section titled “Parameters”](#parameters)

### entity

[Section titled “entity”](#entity)

`Entity` | `null` | `undefined`

## Returns

[Section titled “Returns”](#returns)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; }

#### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

KayKit texture set applied to this tile.

***

`undefined`

# useTileState

> **useTileState**(`entity`): { `baseAssetId`: `string`; `coastEdges`: `number`; `coastWaterless`: `boolean`; `coordinates`: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `key`: `string`; `riverCrossing`: `"A"` | `"B"` | `undefined`; `riverCurvy`: `boolean`; `riverEdges`: `number`; `riverWaterless`: `boolean`; `roadEdges`: `number`; `roadSlope`: `"high"` | `"low"` | `undefined`; `supportAssetId`: `string`; `tags`: `string`\[]; `terrain`: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/); `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; } | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:935](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L935)

Read the canonical tile trait for one tile entity.

## Parameters

[Section titled “Parameters”](#parameters)

### entity

[Section titled “entity”](#entity)

`Entity` | `null` | `undefined`

## Returns

[Section titled “Returns”](#returns)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `baseAssetId`: `string`; `coastEdges`: `number`; `coastWaterless`: `boolean`; `coordinates`: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `key`: `string`; `riverCrossing`: `"A"` | `"B"` | `undefined`; `riverCurvy`: `boolean`; `riverEdges`: `number`; `riverWaterless`: `boolean`; `roadEdges`: `number`; `roadSlope`: `"high"` | `"low"` | `undefined`; `supportAssetId`: `string`; `tags`: `string`\[]; `terrain`: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/); `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; }

#### baseAssetId

[Section titled “baseAssetId”](#baseassetid)

> **baseAssetId**: `string` = `''`

Asset id for the visible tile top.

#### coastEdges

[Section titled “coastEdges”](#coastedges)

> **coastEdges**: `number` = `0`

Six-edge bitmask for coast connectivity.

#### coastWaterless

[Section titled “coastWaterless”](#coastwaterless)

> **coastWaterless**: `boolean` = `false`

Whether this coast tile uses the waterless guide variant.

#### coordinates

[Section titled “coordinates”](#coordinates)

> **coordinates**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Axial tile coordinates.

#### elevation

[Section titled “elevation”](#elevation)

> **elevation**: `number` = `0`

Stacked elevation level for the tile top.

#### key

[Section titled “key”](#key)

> **key**: `string` = `''`

Stable axial key in `q,r` form.

#### riverCrossing

[Section titled “riverCrossing”](#rivercrossing)

> **riverCrossing**: `"A"` | `"B"` | `undefined`

River crossing variant, when present.

#### riverCurvy

[Section titled “riverCurvy”](#rivercurvy)

> **riverCurvy**: `boolean` = `false`

Whether this river tile uses the curvy guide variant.

#### riverEdges

[Section titled “riverEdges”](#riveredges)

> **riverEdges**: `number` = `0`

Six-edge bitmask for river connectivity.

#### riverWaterless

[Section titled “riverWaterless”](#riverwaterless)

> **riverWaterless**: `boolean` = `false`

Whether this river tile uses the waterless guide variant.

#### roadEdges

[Section titled “roadEdges”](#roadedges)

> **roadEdges**: `number` = `0`

Six-edge bitmask for road connectivity.

#### roadSlope

[Section titled “roadSlope”](#roadslope)

> **roadSlope**: `"high"` | `"low"` | `undefined`

Road slope variant when a road changes elevation.

#### supportAssetId

[Section titled “supportAssetId”](#supportassetid)

> **supportAssetId**: `string` = `''`

Optional asset id for the vertical support below elevated tiles.

#### tags

[Section titled “tags”](#tags)

> **tags**: `string`\[]

Free-form taxonomy and generation tags.

#### terrain

[Section titled “terrain”](#terrain)

> **terrain**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)

Primary terrain biome represented by this tile.

#### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

KayKit texture set applied to this tile.

***

`undefined`

# useTileTagList

> **useTileTagList**(`entity`): `string`\[] | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:985](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L985)

Read normalized tags attached to one tile entity.

## Parameters

[Section titled “Parameters”](#parameters)

### entity

[Section titled “entity”](#entity)

`Entity` | `null` | `undefined`

## Returns

[Section titled “Returns”](#returns)

`string`\[] | `undefined`

# useTileTerrain

> **useTileTerrain**(`entity`): { `terrain`: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/); } | `undefined`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:951](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L951)

Read terrain classification for one tile entity.

## Parameters

[Section titled “Parameters”](#parameters)

### entity

[Section titled “entity”](#entity)

`Entity` | `null` | `undefined`

## Returns

[Section titled “Returns”](#returns)

### Type Literal

[Section titled “Type Literal”](#type-literal)

{ `terrain`: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/); }

#### terrain

[Section titled “terrain”](#terrain)

> **terrain**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)

Primary terrain biome represented by this tile.

***

`undefined`

# GameboardPlanProviderProps

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:288](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L288)

Props for mounting a serializable plan directly in React.

## Properties

[Section titled “Properties”](#properties)

### children?

[Section titled “children?”](#children)

> `optional` **children?**: `ReactNode`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:292](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L292)

React children that should read the created runtime and world.

***

### plan

[Section titled “plan”](#plan)

> **plan**: [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:290](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L290)

Plan to load into a newly created runtime for this provider instance.

# GameboardRecipeProviderProps

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:298](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L298)

Props for compiling a recipe and mounting the resulting runtime in React.

## Properties

[Section titled “Properties”](#properties)

### children?

[Section titled “children?”](#children)

> `optional` **children?**: `ReactNode`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:304](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L304)

React children that should read the created runtime and world.

***

### overrides?

[Section titled “overrides?”](#overrides)

> `optional` **overrides?**: `Partial`<[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/)>

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:302](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L302)

Optional plan-generation overrides applied while compiling the recipe.

***

### recipe

[Section titled “recipe”](#recipe)

> **recipe**: [`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:300](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L300)

Recipe to compile into a live runtime.

# GameboardRuntimeProviderProps

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:276](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L276)

Props for mounting an already-created runtime in React.

Use this when the scene, router, save loader, or test harness owns runtime creation and React should consume the same Koota world plus recipe/scenario helpers.

## Type Parameters

[Section titled “Type Parameters”](#type-parameters)

### TRuntime

[Section titled “TRuntime”](#truntime)

`TRuntime` *extends* [`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/) = [`GameboardRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardruntime/)

## Properties

[Section titled “Properties”](#properties)

### children?

[Section titled “children?”](#children)

> `optional` **children?**: `ReactNode`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:282](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L282)

React children that should read the runtime’s Koota world.

***

### runtime

[Section titled “runtime”](#runtime)

> **runtime**: `TRuntime`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:280](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L280)

Runtime facade for the board instance mounted below this provider.

# GameboardScenarioProviderProps

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:310](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L310)

Props for compiling a scenario and mounting the resulting runtime in React.

## Properties

[Section titled “Properties”](#properties)

### children?

[Section titled “children?”](#children)

> `optional` **children?**: `ReactNode`

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:316](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L316)

React children that should read the created runtime and world.

***

### overrides?

[Section titled “overrides?”](#overrides)

> `optional` **overrides?**: `Partial`<[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/)>

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:314](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L314)

Optional recipe overrides applied while compiling the scenario board.

***

### scenario

[Section titled “scenario”](#scenario)

> **scenario**: [`GameboardScenario`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenario/)

Defined in: [packages/declarative-hex-worlds/src/react/react.ts:312](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/react/react.ts#L312)

Scenario containing the board recipe plus actors, patrols, movement, and quests.

# declarative-hex-worlds

## Modules

[Section titled “Modules”](#modules)

* [actors](/declarative-hex-worlds/reference/actors/readme/)
* [cli/cli](/declarative-hex-worlds/reference/cli/cli/readme/)
* [cli/commands/bootstrap](/declarative-hex-worlds/reference/cli/commands/bootstrap/readme/)
* [cli/commands/bootstrap/upstream-layout](/declarative-hex-worlds/reference/cli/commands/bootstrap/upstream-layout/readme/)
* [commands](/declarative-hex-worlds/reference/commands/readme/)
* [coordinates](/declarative-hex-worlds/reference/coordinates/readme/)
* [coordinates/grid](/declarative-hex-worlds/reference/coordinates/grid/readme/)
* [coordinates/layout](/declarative-hex-worlds/reference/coordinates/layout/readme/)
* [coordinates/projection](/declarative-hex-worlds/reference/coordinates/projection/readme/)
* [errors](/declarative-hex-worlds/reference/errors/readme/)
* [gameboard](/declarative-hex-worlds/reference/gameboard/readme/)
* [gameboard/navigation](/declarative-hex-worlds/reference/gameboard/navigation/readme/)
* [gameboard/occupancy](/declarative-hex-worlds/reference/gameboard/occupancy/readme/)
* [index](/declarative-hex-worlds/reference/index/readme/)
* [ingest](/declarative-hex-worlds/reference/ingest/readme/)
* [interop](/declarative-hex-worlds/reference/interop/readme/)
* [interop/compatibility](/declarative-hex-worlds/reference/interop/compatibility/readme/)
* [interop/coverage](/declarative-hex-worlds/reference/interop/coverage/readme/)
* [koota](/declarative-hex-worlds/reference/koota/readme/)
* [manifest/free](/declarative-hex-worlds/reference/manifest/free/readme/)
* [manifest/schema](/declarative-hex-worlds/reference/manifest/schema/readme/)
* [movement](/declarative-hex-worlds/reference/movement/readme/)
* [patrol](/declarative-hex-worlds/reference/patrol/readme/)
* [pieces](/declarative-hex-worlds/reference/pieces/readme/)
* [quests](/declarative-hex-worlds/reference/quests/readme/)
* [react](/declarative-hex-worlds/reference/react/readme/)
* [rules](/declarative-hex-worlds/reference/rules/readme/)
* [rules/rule-types](/declarative-hex-worlds/reference/rules/rule-types/readme/)
* [rules/validation](/declarative-hex-worlds/reference/rules/validation/readme/)
* [runtime](/declarative-hex-worlds/reference/runtime/readme/)
* [scenario](/declarative-hex-worlds/reference/scenario/readme/)
* [scenario/blueprint](/declarative-hex-worlds/reference/scenario/blueprint/readme/)
* [scenario/catalog](/declarative-hex-worlds/reference/scenario/catalog/readme/)
* [scenario/recipe](/declarative-hex-worlds/reference/scenario/recipe/readme/)
* [scenario/registry](/declarative-hex-worlds/reference/scenario/registry/readme/)
* [selectors](/declarative-hex-worlds/reference/selectors/readme/)
* [simulation](/declarative-hex-worlds/reference/simulation/readme/)
* [systems](/declarative-hex-worlds/reference/systems/readme/)
* [systems/world-rules-system](/declarative-hex-worlds/reference/systems/world-rules-system/readme/)
* [three](/declarative-hex-worlds/reference/three/readme/)
* [traits](/declarative-hex-worlds/reference/traits/readme/)
* [types](/declarative-hex-worlds/reference/types/readme/)

# GameboardRuleConfig

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:25](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L25)

Shared validation rule toggles for plans and worlds.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`GameboardPlanValidationConfig`](/declarative-hex-worlds/reference/rules/validation/interfaces/gameboardplanvalidationconfig/)

## Properties

[Section titled “Properties”](#properties)

### forbidStructuresOnWater?

[Section titled “forbidStructuresOnWater?”](#forbidstructuresonwater)

> `optional` **forbidStructuresOnWater?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:35](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L35)

Whether structure placements are forbidden on water tiles.

***

### maxElevation?

[Section titled “maxElevation?”](#maxelevation)

> `optional` **maxElevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:27](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L27)

Maximum allowed tile elevation.

***

### requireCoastsTouchWater?

[Section titled “requireCoastsTouchWater?”](#requirecoaststouchwater)

> `optional` **requireCoastsTouchWater?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L33)

Whether coast edges should face adjacent water tiles.

***

### requireHarborsTouchWater?

[Section titled “requireHarborsTouchWater?”](#requireharborstouchwater)

> `optional` **requireHarborsTouchWater?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:37](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L37)

Whether harbor placements must face adjacent water tiles.

***

### requireReciprocalRivers?

[Section titled “requireReciprocalRivers?”](#requirereciprocalrivers)

> `optional` **requireReciprocalRivers?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:31](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L31)

Whether river edges must connect back from neighboring tiles.

***

### requireReciprocalRoads?

[Section titled “requireReciprocalRoads?”](#requirereciprocalroads)

> `optional` **requireReciprocalRoads?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:29](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L29)

Whether road edges must connect back from neighboring tiles.

# GameboardRuleViolation

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:11](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L11)

One validation or rule violation emitted by plan, world, recipe, or scenario checks.

## Properties

[Section titled “Properties”](#properties)

### code

[Section titled “code”](#code)

> **code**: `string`

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:13](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L13)

Stable machine-readable violation code.

***

### message

[Section titled “message”](#message)

> **message**: `string`

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:17](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L17)

Human-readable diagnostic message.

***

### placementId?

[Section titled “placementId?”](#placementid)

> `optional` **placementId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:21](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L21)

Related placement id when the violation is placement-specific.

***

### severity

[Section titled “severity”](#severity)

> **severity**: [`RuleSeverity`](/declarative-hex-worlds/reference/rules/rule-types/type-aliases/ruleseverity/)

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:15](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L15)

Diagnostic severity.

***

### tileKey?

[Section titled “tileKey?”](#tilekey)

> `optional` **tileKey?**: `string`

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:19](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L19)

Related tile key when the violation is tile-specific.

# RuleSeverity

> **RuleSeverity** = `"error"` | `"warning"`

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:8](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L8)

Severity level for validation and rule diagnostics.

# canStackInPlan

> **canStackInPlan**(`plan`, `coordinates`, `height`, `config?`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/rules/validation.ts:109](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/validation.ts#L109)

Checks whether a tile in a plan can support the requested elevation.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### height

[Section titled “height”](#height)

`number`

### config?

[Section titled “config?”](#config)

[`GameboardPlanValidationConfig`](/declarative-hex-worlds/reference/rules/validation/interfaces/gameboardplanvalidationconfig/) = `{}`

## Returns

[Section titled “Returns”](#returns)

`boolean`

# validateGameboardPlan

> **validateGameboardPlan**(`plan`, `config?`): [`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

Defined in: [packages/declarative-hex-worlds/src/rules/validation.ts:71](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/validation.ts#L71)

Validates a gameboard plan for connectivity, stacking, asset, and occupancy rules.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### config?

[Section titled “config?”](#config)

[`GameboardPlanValidationConfig`](/declarative-hex-worlds/reference/rules/validation/interfaces/gameboardplanvalidationconfig/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

# GameboardPlanValidationConfig

Defined in: [packages/declarative-hex-worlds/src/rules/validation.ts:21](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/validation.ts#L21)

Validation config for complete gameboard plans.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardRuleConfig`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleconfig/)

## Properties

[Section titled “Properties”](#properties)

### allowUnknownAssetIds?

[Section titled “allowUnknownAssetIds?”](#allowunknownassetids)

> `optional` **allowUnknownAssetIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/rules/validation.ts:31](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/validation.ts#L31)

Specific unknown asset ids to allow even when unknown assets are otherwise errors.

***

### allowUnknownAssets?

[Section titled “allowUnknownAssets?”](#allowunknownassets)

> `optional` **allowUnknownAssets?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/rules/validation.ts:29](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/validation.ts#L29)

Whether unknown asset ids are allowed.

***

### assetCatalog?

[Section titled “assetCatalog?”](#assetcatalog)

> `optional` **assetCatalog?**: [`ManifestAssetCatalog`](/declarative-hex-worlds/reference/manifest/schema/type-aliases/manifestassetcatalog/)

Defined in: [packages/declarative-hex-worlds/src/rules/validation.ts:27](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/validation.ts#L27)

Optional manifest catalog used to validate asset ids and editions.

***

### forbidStructuresOnWater?

[Section titled “forbidStructuresOnWater?”](#forbidstructuresonwater)

> `optional` **forbidStructuresOnWater?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:35](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L35)

Whether structure placements are forbidden on water tiles.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardRuleConfig`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleconfig/).[`forbidStructuresOnWater`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleconfig/#forbidstructuresonwater)

***

### maxElevation?

[Section titled “maxElevation?”](#maxelevation)

> `optional` **maxElevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:27](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L27)

Maximum allowed tile elevation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardRuleConfig`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleconfig/).[`maxElevation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleconfig/#maxelevation)

***

### registry?

[Section titled “registry?”](#registry)

> `optional` **registry?**: [`HexTileRegistry`](/declarative-hex-worlds/reference/scenario/registry/interfaces/hextileregistry/)

Defined in: [packages/declarative-hex-worlds/src/rules/validation.ts:23](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/validation.ts#L23)

Optional tile declaration registry for declaration-aware validation.

***

### requireCoastsTouchWater?

[Section titled “requireCoastsTouchWater?”](#requirecoaststouchwater)

> `optional` **requireCoastsTouchWater?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L33)

Whether coast edges should face adjacent water tiles.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardRuleConfig`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleconfig/).[`requireCoastsTouchWater`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleconfig/#requirecoaststouchwater)

***

### requireExtraAssetFlags?

[Section titled “requireExtraAssetFlags?”](#requireextraassetflags)

> `optional` **requireExtraAssetFlags?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/rules/validation.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/validation.ts#L33)

Whether EXTRA assets must be marked with `requiresExtra`.

***

### requireHarborsTouchWater?

[Section titled “requireHarborsTouchWater?”](#requireharborstouchwater)

> `optional` **requireHarborsTouchWater?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:37](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L37)

Whether harbor placements must face adjacent water tiles.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardRuleConfig`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleconfig/).[`requireHarborsTouchWater`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleconfig/#requireharborstouchwater)

***

### requireReciprocalRivers?

[Section titled “requireReciprocalRivers?”](#requirereciprocalrivers)

> `optional` **requireReciprocalRivers?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:31](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L31)

Whether river edges must connect back from neighboring tiles.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardRuleConfig`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleconfig/).[`requireReciprocalRivers`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleconfig/#requirereciprocalrivers)

***

### requireReciprocalRoads?

[Section titled “requireReciprocalRoads?”](#requirereciprocalroads)

> `optional` **requireReciprocalRoads?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/rules/rule-types.ts:29](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/rule-types.ts#L29)

Whether road edges must connect back from neighboring tiles.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardRuleConfig`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleconfig/).[`requireReciprocalRoads`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleconfig/#requirereciprocalroads)

***

### validatePlacementBlockingOverlap?

[Section titled “validatePlacementBlockingOverlap?”](#validateplacementblockingoverlap)

> `optional` **validatePlacementBlockingOverlap?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/rules/validation.ts:37](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/validation.ts#L37)

Whether blocking placements may overlap.

***

### validatePlacementFootprints?

[Section titled “validatePlacementFootprints?”](#validateplacementfootprints)

> `optional` **validatePlacementFootprints?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/rules/validation.ts:35](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/validation.ts#L35)

Whether placement layout footprints must point at existing tiles.

***

### validateRegisteredDeclarations?

[Section titled “validateRegisteredDeclarations?”](#validateregistereddeclarations)

> `optional` **validateRegisteredDeclarations?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/rules/validation.ts:25](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/rules/validation.ts#L25)

Whether to validate base/support assets and declaration adjacency rules.

# createGameboardBlueprintPlan

> **createGameboardBlueprintPlan**(`options?`): [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:275](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L275)

Compile a high-level 2.5D board blueprint directly into a gameboard plan.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`GameboardBlueprintOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

# createGameboardBlueprintRecipe

> **createGameboardBlueprintRecipe**(`options?`): [`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:268](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L268)

Compile a high-level 2.5D board blueprint into a serializable recipe.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`GameboardBlueprintOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

# createGameboardBlueprintScenario

> **createGameboardBlueprintScenario**(`options?`): [`GameboardScenario`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenario/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:293](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L293)

Compile board intent plus spawn groups, actors, patrols, and quests into a scenario.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`GameboardBlueprintScenarioOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardScenario`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenario/)

# createGameboardWorldFromBlueprint

> **createGameboardWorldFromBlueprint**(`options?`): [`GameboardScenarioRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenarioruntime/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:300](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L300)

Compile a blueprint scenario and instantiate it into a ready Koota runtime.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`GameboardBlueprintScenarioOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardScenarioRuntime`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenarioruntime/)

# createMedievalShowcaseBlueprintRecipe

> **createMedievalShowcaseBlueprintRecipe**(`options?`): [`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:321](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L321)

Create a comprehensive showcase recipe with mountains, towns, roads, harbors, biomes, and transitions.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`GameboardBlueprintOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

# inspectGameboardBlueprint

> **inspectGameboardBlueprint**(`options?`): [`GameboardBlueprintInspection`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintinspection/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:282](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L282)

Compile, build, and summarize a high-level 2.5D board blueprint.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`GameboardBlueprintOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardBlueprintInspection`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintinspection/)

# inspectGameboardBlueprintScenario

> **inspectGameboardBlueprintScenario**(`options?`, `config?`): [`GameboardBlueprintScenarioInspection`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenarioinspection/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:307](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L307)

Inspect both generated board intent and playable scenario wiring.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`GameboardBlueprintScenarioOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/) = `{}`

### config?

[Section titled “config?”](#config)

[`GameboardScenarioValidationConfig`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariovalidationconfig/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardBlueprintScenarioInspection`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenarioinspection/)

# BiomeFillSpec

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:54](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L54)

Texture-set fill target for authored or generated biome regions.

## Properties

[Section titled “Properties”](#properties)

### center?

[Section titled “center?”](#center)

> `optional` **center?**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:62](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L62)

Optional center used to bias the selected biome tiles.

***

### fill

[Section titled “fill”](#fill)

> **fill**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:60](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L60)

Fraction of eligible land tiles to paint with this texture set.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:56](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L56)

Optional id used in diagnostics and future editor UIs.

***

### radius?

[Section titled “radius?”](#radius)

> `optional` **radius?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:64](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L64)

Optional radius around `center` that bounds the biome.

***

### terrain?

[Section titled “terrain?”](#terrain)

> `optional` **terrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/) | readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:66](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L66)

Optional terrain filter for biome assignment.

***

### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L58)

Texture set applied to the selected tiles.

# GameboardBlueprintInspection

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:206](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L206)

Diagnostic summary for one compiled blueprint.

## Properties

[Section titled “Properties”](#properties)

### counts

[Section titled “counts”](#counts)

> **counts**: `Readonly`<`Record`<`string`, `number`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:214](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L214)

Feature counts emitted by the compiler.

***

### plan

[Section titled “plan”](#plan)

> **plan**: [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:210](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L210)

Compiled concrete plan.

***

### recipe

[Section titled “recipe”](#recipe)

> **recipe**: [`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:208](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L208)

Generated recipe.

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:212](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L212)

Non-fatal blueprint diagnostics.

# GameboardBlueprintOptions

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:174](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L174)

High-level options for compiling a full 2.5D medieval board.

## Extends

[Section titled “Extends”](#extends)

* `Partial`<[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/)>

## Extended by

[Section titled “Extended by”](#extended-by)

* [`GameboardBlueprintScenarioOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/)

## Properties

[Section titled “Properties”](#properties)

### biomeFills?

[Section titled “biomeFills?”](#biomefills)

> `optional` **biomeFills?**: readonly [`BiomeFillSpec`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/biomefillspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:184](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L184)

Texture-set fill targets for biome regions.

***

### defaultTerrain?

[Section titled “defaultTerrain?”](#defaultterrain)

> `optional` **defaultTerrain?**: `"grass"` | `"water"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:119](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L119)

Initial terrain used for every generated tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/).[`defaultTerrain`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/#defaultterrain)

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:178](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L178)

Primary faction used by generated towns, harbors, and units.

***

### harbors?

[Section titled “harbors?”](#harbors)

> `optional` **harbors?**: `number` | readonly [`MedievalHarborSpec`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/medievalharborspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:194](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L194)

Authored harbors, or a count for deterministic coast placement.

***

### layoutDensity?

[Section titled “layoutDensity?”](#layoutdensity)

> `optional` **layoutDensity?**: [`SeededGameboardLayoutDensityOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardlayoutdensityoptions/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:200](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L200)

Optional generated density fills attached to the resulting recipe.

***

### layoutFillSeed?

[Section titled “layoutFillSeed?”](#layoutfillseed)

> `optional` **layoutFillSeed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:202](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L202)

Seed used for generated density fills.

***

### maxElevation?

[Section titled “maxElevation?”](#maxelevation)

> `optional` **maxElevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:182](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L182)

Highest generated elevation used by default mountain ranges.

***

### mountainRanges?

[Section titled “mountainRanges?”](#mountainranges)

> `optional` **mountainRanges?**: readonly [`MedievalMountainRangeSpec`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/medievalmountainrangespec/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:186](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L186)

Authored mountain ranges. Omit to create one default ridge.

***

### propClusterDressing?

[Section titled “propClusterDressing?”](#propclusterdressing)

> `optional` **propClusterDressing?**: `false` | [`MedievalPropClusterDressingOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/medievalpropclusterdressingoptions/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:196](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L196)

Generated and authored semantic prop-cluster dressing. Pass false to disable.

***

### rivers?

[Section titled “rivers?”](#rivers)

> `optional` **rivers?**: readonly [`MedievalRiverNetworkSpec`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/medievalrivernetworkspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:192](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L192)

Authored river networks. Omit to create one mountain-to-coast river.

***

### roads?

[Section titled “roads?”](#roads)

> `optional` **roads?**: readonly [`MedievalRoadNetworkSpec`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/medievalroadnetworkspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:190](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L190)

Authored road networks. Auto roads connect towns and harbors.

***

### seed?

[Section titled “seed?”](#seed)

> `optional` **seed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:113](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L113)

Deterministic seed for generation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/).[`seed`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/#seed)

***

### shape?

[Section titled “shape?”](#shape)

> `optional` **shape?**: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:176](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L176)

Board shape to compile.

#### Overrides

[Section titled “Overrides”](#overrides)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/).[`shape`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/#shape)

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:117](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L117)

Texture set applied to generated terrain.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/).[`textureSet`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/#textureset)

***

### towns?

[Section titled “towns?”](#towns)

> `optional` **towns?**: `number` | readonly [`MedievalTownSpec`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/medievaltownspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:188](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L188)

Authored towns, or a count for deterministic town placement.

***

### transitionPolicy?

[Section titled “transitionPolicy?”](#transitionpolicy)

> `optional` **transitionPolicy?**: [`MedievalTransitionPolicy`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/medievaltransitionpolicy/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:198](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L198)

Visual and access transition policy.

***

### waterFill?

[Section titled “waterFill?”](#waterfill)

> `optional` **waterFill?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:180](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L180)

Fraction of the board reserved for water. Defaults to a southern coast.

# GameboardBlueprintScenarioInspection

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:228](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L228)

Combined blueprint and scenario diagnostics for generated playable boards.

## Properties

[Section titled “Properties”](#properties)

### blueprint

[Section titled “blueprint”](#blueprint)

> **blueprint**: [`GameboardBlueprintInspection`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintinspection/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:230](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L230)

Blueprint inspection, including the generated recipe and compiled plan.

***

### scenario

[Section titled “scenario”](#scenario)

> **scenario**: [`GameboardScenario`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenario/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:232](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L232)

Scenario produced from the generated recipe and authored runtime content.

***

### scenarioInspection

[Section titled “scenarioInspection”](#scenarioinspection)

> **scenarioInspection**: [`GameboardScenarioValidationResult`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariovalidationresult/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:234](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L234)

Scenario validation result, including spawn groups and patrol routes.

# GameboardBlueprintScenarioOptions

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:218](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L218)

Scenario-level options for compiling a blueprint into playable content.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardBlueprintOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintoptions/).`Omit`<[`CreateGameboardScenarioOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardscenariooptions/), `"metadata"`>

## Properties

[Section titled “Properties”](#properties)

### actors?

[Section titled “actors?”](#actors)

> `optional` **actors?**: readonly [`GameboardScenarioActor`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenarioactor/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L126)

Actors to spawn into the scenario runtime.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`CreateGameboardScenarioOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardscenariooptions/).[`actors`](/declarative-hex-worlds/reference/index/interfaces/creategameboardscenariooptions/#actors)

***

### biomeFills?

[Section titled “biomeFills?”](#biomefills)

> `optional` **biomeFills?**: readonly [`BiomeFillSpec`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/biomefillspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:184](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L184)

Texture-set fill targets for biome regions.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardBlueprintScenarioOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/).[`biomeFills`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/#biomefills)

***

### defaultTerrain?

[Section titled “defaultTerrain?”](#defaultterrain)

> `optional` **defaultTerrain?**: `"grass"` | `"water"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:119](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L119)

Initial terrain used for every generated tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/).[`defaultTerrain`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/#defaultterrain)

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:178](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L178)

Primary faction used by generated towns, harbors, and units.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardBlueprintOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintoptions/).[`faction`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintoptions/#faction)

***

### harbors?

[Section titled “harbors?”](#harbors)

> `optional` **harbors?**: `number` | readonly [`MedievalHarborSpec`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/medievalharborspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:194](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L194)

Authored harbors, or a count for deterministic coast placement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardBlueprintScenarioOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/).[`harbors`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/#harbors)

***

### layoutDensity?

[Section titled “layoutDensity?”](#layoutdensity)

> `optional` **layoutDensity?**: [`SeededGameboardLayoutDensityOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardlayoutdensityoptions/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:200](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L200)

Optional generated density fills attached to the resulting recipe.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardBlueprintOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintoptions/).[`layoutDensity`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintoptions/#layoutdensity)

***

### layoutFillSeed?

[Section titled “layoutFillSeed?”](#layoutfillseed)

> `optional` **layoutFillSeed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:202](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L202)

Seed used for generated density fills.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardBlueprintScenarioOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/).[`layoutFillSeed`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/#layoutfillseed)

***

### maxElevation?

[Section titled “maxElevation?”](#maxelevation)

> `optional` **maxElevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:182](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L182)

Highest generated elevation used by default mountain ranges.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardBlueprintOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintoptions/).[`maxElevation`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintoptions/#maxelevation)

***

### mountainRanges?

[Section titled “mountainRanges?”](#mountainranges)

> `optional` **mountainRanges?**: readonly [`MedievalMountainRangeSpec`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/medievalmountainrangespec/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:186](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L186)

Authored mountain ranges. Omit to create one default ridge.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`GameboardBlueprintScenarioOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/).[`mountainRanges`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/#mountainranges)

***

### patrolRoutes?

[Section titled “patrolRoutes?”](#patrolroutes)

> `optional` **patrolRoutes?**: readonly [`GameboardScenarioPatrolRoute`](/declarative-hex-worlds/reference/index/interfaces/gameboardscenariopatrolroute/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:124](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L124)

Deterministic patrol route rules for scenario actors.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`CreateGameboardScenarioOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardscenariooptions/).[`patrolRoutes`](/declarative-hex-worlds/reference/index/interfaces/creategameboardscenariooptions/#patrolroutes)

***

### propClusterDressing?

[Section titled “propClusterDressing?”](#propclusterdressing)

> `optional` **propClusterDressing?**: `false` | [`MedievalPropClusterDressingOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/medievalpropclusterdressingoptions/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:196](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L196)

Generated and authored semantic prop-cluster dressing. Pass false to disable.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`GameboardBlueprintScenarioOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/).[`propClusterDressing`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/#propclusterdressing)

***

### quests?

[Section titled “quests?”](#quests)

> `optional` **quests?**: readonly [`GameboardQuestDefinition`](/declarative-hex-worlds/reference/index/interfaces/gameboardquestdefinition/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L128)

Quests to spawn into the scenario runtime.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`CreateGameboardScenarioOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardscenariooptions/).[`quests`](/declarative-hex-worlds/reference/index/interfaces/creategameboardscenariooptions/#quests)

***

### rivers?

[Section titled “rivers?”](#rivers)

> `optional` **rivers?**: readonly [`MedievalRiverNetworkSpec`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/medievalrivernetworkspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:192](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L192)

Authored river networks. Omit to create one mountain-to-coast river.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

[`GameboardBlueprintScenarioOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/).[`rivers`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/#rivers)

***

### roads?

[Section titled “roads?”](#roads)

> `optional` **roads?**: readonly [`MedievalRoadNetworkSpec`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/medievalroadnetworkspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:190](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L190)

Authored road networks. Auto roads connect towns and harbors.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`GameboardBlueprintScenarioOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/).[`roads`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/#roads)

***

### scenarioId?

[Section titled “scenarioId?”](#scenarioid)

> `optional` **scenarioId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:222](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L222)

Stable scenario id. Defaults to `medieval-blueprint:<seed>`.

***

### scenarioMetadata?

[Section titled “scenarioMetadata?”](#scenariometadata)

> `optional` **scenarioMetadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:224](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L224)

Serializable metadata attached to the scenario.

***

### seed?

[Section titled “seed?”](#seed)

> `optional` **seed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:113](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L113)

Deterministic seed for generation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-14)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/).[`seed`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/#seed)

***

### shape?

[Section titled “shape?”](#shape)

> `optional` **shape?**: [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:176](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L176)

Board shape to compile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-15)

[`GameboardBlueprintOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintoptions/).[`shape`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintoptions/#shape)

***

### spawnGroups?

[Section titled “spawnGroups?”](#spawngroups)

> `optional` **spawnGroups?**: `GameboardSpawnGroupOptions`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:122](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L122)

Deterministic spawn group rules for scenario actors.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-16)

[`CreateGameboardScenarioOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardscenariooptions/).[`spawnGroups`](/declarative-hex-worlds/reference/index/interfaces/creategameboardscenariooptions/#spawngroups)

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:117](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L117)

Texture set applied to generated terrain.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-17)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/).[`textureSet`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/#textureset)

***

### title?

[Section titled “title?”](#title)

> `optional` **title?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/scenario.ts:120](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/scenario.ts#L120)

Optional display title.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-18)

[`CreateGameboardScenarioOptions`](/declarative-hex-worlds/reference/index/interfaces/creategameboardscenariooptions/).[`title`](/declarative-hex-worlds/reference/index/interfaces/creategameboardscenariooptions/#title)

***

### towns?

[Section titled “towns?”](#towns)

> `optional` **towns?**: `number` | readonly [`MedievalTownSpec`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/medievaltownspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:188](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L188)

Authored towns, or a count for deterministic town placement.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-19)

[`GameboardBlueprintScenarioOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/).[`towns`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintscenariooptions/#towns)

***

### transitionPolicy?

[Section titled “transitionPolicy?”](#transitionpolicy)

> `optional` **transitionPolicy?**: [`MedievalTransitionPolicy`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/medievaltransitionpolicy/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:198](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L198)

Visual and access transition policy.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-20)

[`GameboardBlueprintOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintoptions/).[`transitionPolicy`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintoptions/#transitionpolicy)

***

### waterFill?

[Section titled “waterFill?”](#waterfill)

> `optional` **waterFill?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:180](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L180)

Fraction of the board reserved for water. Defaults to a southern coast.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-21)

[`GameboardBlueprintOptions`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintoptions/).[`waterFill`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/gameboardblueprintoptions/#waterfill)

# MedievalHarborSpec

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L126)

Authored harbor or port cluster.

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L130)

Coast tile where the harbor is anchored.

***

### facing

[Section titled “facing”](#facing)

> **facing**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:132](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L132)

Edge facing adjacent water.

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L134)

Faction used for faction-colored harbor assets.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L128)

Optional harbor id used in diagnostics.

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`HarborKind`](/declarative-hex-worlds/reference/index/type-aliases/harborkind/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L136)

Harbor asset variant.

***

### roadTo?

[Section titled “roadTo?”](#roadto)

> `optional` **roadTo?**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:138](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L138)

Optional inland road target.

# MedievalMountainRangeSpec

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:70](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L70)

Multi-tile elevated mountain range intent.

## Properties

[Section titled “Properties”](#properties)

### height?

[Section titled “height?”](#height)

> `optional` **height?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:78](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L78)

Highest stack height in the range. Defaults to blueprint `maxElevation`.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:72](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L72)

Optional range id used in diagnostics and generated metadata.

***

### path

[Section titled “path”](#path)

> **path**: readonly [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:74](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L74)

Ridge path. Width expands around these coordinates.

***

### treeLine?

[Section titled “treeLine?”](#treeline)

> `optional` **treeLine?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:82](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L82)

Include tree-covered mountain assets above this normalized height.

***

### variant?

[Section titled “variant?”](#variant)

> `optional` **variant?**: [`MountainVariant`](/declarative-hex-worlds/reference/index/type-aliases/mountainvariant/) | `"cycle"`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:80](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L80)

Mountain visual variant or deterministic cycling. Defaults to `cycle`.

***

### width?

[Section titled “width?”](#width)

> `optional` **width?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:76](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L76)

Radius around the ridge path to include. Defaults to `1`.

# MedievalPropClusterDressingOptions

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:148](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L148)

Policy for contextual prop clusters generated around towns and harbors.

## Properties

[Section titled “Properties”](#properties)

### auto?

[Section titled “auto?”](#auto)

> `optional` **auto?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:150](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L150)

Generate context-aware town and harbor clusters. Defaults to true.

***

### clusters?

[Section titled “clusters?”](#clusters)

> `optional` **clusters?**: readonly [`MedievalPropClusterDressingSpec`](/declarative-hex-worlds/reference/scenario/blueprint/interfaces/medievalpropclusterdressingspec/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:158](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L158)

Additional authored prop clusters compiled into the recipe.

***

### density?

[Section titled “density?”](#density)

> `optional` **density?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:152](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L152)

Default density for generated clusters. Defaults to `0.55`.

***

### includeExtra?

[Section titled “includeExtra?”](#includeextra)

> `optional` **includeExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:156](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L156)

Include local-only EXTRA prop assets in generated clusters. Defaults to false.

***

### placement?

[Section titled “placement?”](#placement)

> `optional` **placement?**: [`PropClusterPlacement`](/declarative-hex-worlds/reference/index/type-aliases/propclusterplacement/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:154](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L154)

Default cluster distribution for generated clusters. Defaults to `adjacent`.

# MedievalPropClusterDressingSpec

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:142](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L142)

Authored or generated semantic prop-cluster dressing.

## Extends

[Section titled “Extends”](#extends)

* `Omit`<[`PropClusterOptions`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/), `"clusterId"`>

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:576](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L576)

Anchor tile for the cluster.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`AddPropClusterRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/).[`at`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/#at)

***

### density?

[Section titled “density?”](#density)

> `optional` **density?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:584](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L584)

Percentage of the cluster’s available asset list to place, from 0 to 1. Defaults to 1.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`AddPropClusterRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/).[`density`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/#density)

***

### facing?

[Section titled “facing?”](#facing)

> `optional` **facing?**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:580](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L580)

Edge used to orient adjacent spread patterns.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`AddPropClusterRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/).[`facing`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/#facing)

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:144](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L144)

Optional stable id used for generated metadata and diagnostics.

***

### includeExtra?

[Section titled “includeExtra?”](#includeextra)

> `optional` **includeExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:586](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L586)

Include local-only EXTRA prop assets when the cluster kind has them. Defaults to false.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`AddPropClusterRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/).[`includeExtra`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/#includeextra)

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`PropClusterKind`](/declarative-hex-worlds/reference/index/type-aliases/propclusterkind/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:578](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L578)

Cluster purpose. Determines the default asset list.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`AddPropClusterRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/).[`kind`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/#kind)

***

### placement?

[Section titled “placement?”](#placement)

> `optional` **placement?**: [`PropClusterPlacement`](/declarative-hex-worlds/reference/index/type-aliases/propclusterplacement/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:582](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L582)

Whether assets stack on one tile or spread to neighboring tiles. Defaults to `adjacent`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`AddPropClusterRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/).[`placement`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/#placement)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:590](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L590)

Base clockwise 60-degree rotation steps. Defaults to `facing`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`AddPropClusterRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/).[`rotationSteps`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:592](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L592)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`AddPropClusterRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/).[`scale`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/#scale)

# MedievalRiverNetworkSpec

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:114](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L114)

Authored river network.

## Properties

[Section titled “Properties”](#properties)

### curvy?

[Section titled “curvy?”](#curvy)

> `optional` **curvy?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:122](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L122)

Whether to prefer curvy river overlays.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:116](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L116)

Optional river id used in diagnostics.

***

### path

[Section titled “path”](#path)

> **path**: readonly [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:118](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L118)

Ordered coordinates for the river path.

***

### waterless?

[Section titled “waterless?”](#waterless)

> `optional` **waterless?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:120](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L120)

Whether to use waterless river overlays.

# MedievalRoadNetworkSpec

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:102](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L102)

Authored multi-segment road network.

## Properties

[Section titled “Properties”](#properties)

### addBridges?

[Section titled “addBridges?”](#addbridges)

> `optional` **addBridges?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:110](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L110)

Add bridge structures where the road crosses water.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:104](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L104)

Optional road id used in diagnostics.

***

### path

[Section titled “path”](#path)

> **path**: readonly [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:106](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L106)

Ordered coordinates for the road path.

***

### slope?

[Section titled “slope?”](#slope)

> `optional` **slope?**: [`RoadSlope`](/declarative-hex-worlds/reference/index/type-aliases/roadslope/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:108](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L108)

Optional road slope variant for this path.

# MedievalTownSpec

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L86)

Authored town or settlement cluster.

## Properties

[Section titled “Properties”](#properties)

### buildings?

[Section titled “buildings?”](#buildings)

> `optional` **buildings?**: readonly (`"archeryrange"` | `"barracks"` | `"blacksmith"` | `"castle"` | `"church"` | `"docks"` | `"home_A"` | `"home_B"` | `"lumbermill"` | `"market"` | `"mine"` | `"shipyard"` | `"shrine"` | `"stables"` | `"tavern"` | `"tent"` | `"townhall"` | `"tower_A"` | `"tower_B"` | `"tower_base"` | `"tower_cannon"` | `"tower_catapult"` | `"watchtower"` | `"watermill"` | `"well"` | `"windmill"` | `"workshop"`)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:94](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L94)

Building sequence to place around the town center.

***

### center

[Section titled “center”](#center)

> **center**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:90](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L90)

Center tile, normally the town hall or market.

***

### connectTo?

[Section titled “connectTo?”](#connectto)

> `optional` **connectTo?**: readonly [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:98](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L98)

Optional road targets that should connect to this town center.

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:92](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L92)

Faction used for faction-colored buildings.

***

### id?

[Section titled “id?”](#id)

> `optional` **id?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L88)

Optional town id used in diagnostics and generated docs.

***

### includeWalls?

[Section titled “includeWalls?”](#includewalls)

> `optional` **includeWalls?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:96](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L96)

Whether to add a small defensive wall/fence ring.

# MedievalTransitionPolicy

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:162](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L162)

Policy for generated visual/access transitions between board regions.

## Properties

[Section titled “Properties”](#properties)

### biomeTransitions?

[Section titled “biomeTransitions?”](#biometransitions)

> `optional` **biomeTransitions?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:164](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L164)

Add EXTRA transition tiles where neighboring texture sets differ.

***

### bridges?

[Section titled “bridges?”](#bridges)

> `optional` **bridges?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:170](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L170)

Add bridge structures where authored roads cross water tiles.

***

### elevationRamps?

[Section titled “elevationRamps?”](#elevationramps)

> `optional` **elevationRamps?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:166](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L166)

Add sloped grass tiles where elevation changes by one level.

***

### roadSlopes?

[Section titled “roadSlopes?”](#roadslopes)

> `optional` **roadSlopes?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/blueprint.ts:168](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/blueprint.ts#L168)

Add sloped road variants where a road crosses one elevation level.

# coloredUnitAssetId

> **coloredUnitAssetId**(`part`, `faction`, `style`): `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:793](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L793)

Builds a faction-colored unit part asset id.

## Parameters

[Section titled “Parameters”](#parameters)

### part

[Section titled “part”](#part)

`"banner"` | `"bow"` | `"cannon"` | `"cart"` | `"cart_merchant"` | `"catapult"` | `"helmet"` | `"horse"` | `"projectile_arrow"` | `"shield"` | `"ship"` | `"spear"` | `"sword"` | `"unit"`

### faction

[Section titled “faction”](#faction)

`"blue"` | `"green"` | `"red"` | `"yellow"`

### style

[Section titled “style”](#style)

`"accent"` | `"full"`

## Returns

[Section titled “Returns”](#returns)

`string`

# describeKayKitAssetTreatment

> **describeKayKitAssetTreatment**(`assetId`): [`KayKitAssetPublicTreatment`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitassetpublictreatment/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:820](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L820)

Returns the public treatment contract for one asset id, if the id is KayKit-owned.

## Parameters

[Section titled “Parameters”](#parameters)

### assetId

[Section titled “assetId”](#assetid)

`string`

## Returns

[Section titled “Returns”](#returns)

[`KayKitAssetPublicTreatment`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitassetpublictreatment/) | `undefined`

# describeKayKitGuideAssetCoverage

> **describeKayKitGuideAssetCoverage**(`assetId`): [`KayKitGuideAssetCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguideassetcoverage/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:1007](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L1007)

Returns guide-page, API, docs, and visual coverage for one asset id.

## Parameters

[Section titled “Parameters”](#parameters)

### assetId

[Section titled “assetId”](#assetid)

`string`

## Returns

[Section titled “Returns”](#returns)

[`KayKitGuideAssetCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguideassetcoverage/) | `undefined`

# describeKayKitGuidePublicApiCoverage

> **describeKayKitGuidePublicApiCoverage**(`publicApi`): [`KayKitGuidePublicApiCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidepublicapicoverage/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:970](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L970)

Returns guide-page and asset coverage for one public API surface.

## Parameters

[Section titled “Parameters”](#parameters)

### publicApi

[Section titled “publicApi”](#publicapi)

`string`

## Returns

[Section titled “Returns”](#returns)

[`KayKitGuidePublicApiCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidepublicapicoverage/) | `undefined`

# describeKayKitGuideRoleCoverage

> **describeKayKitGuideRoleCoverage**(`role`): [`KayKitGuideRoleCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguiderolecoverage/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:988](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L988)

Returns guide-page, API, and asset coverage for one public asset role.

## Parameters

[Section titled “Parameters”](#parameters)

### role

[Section titled “role”](#role)

`string`

## Returns

[Section titled “Returns”](#returns)

[`KayKitGuideRoleCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguiderolecoverage/) | `undefined`

# describeKayKitGuideScenario

> **describeKayKitGuideScenario**(`id`): [`KayKitGuideScenario`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenario/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:827](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L827)

Returns the decomposed guide-page scenario contract for one scenario id.

## Parameters

[Section titled “Parameters”](#parameters)

### id

[Section titled “id”](#id)

`string`

## Returns

[Section titled “Returns”](#returns)

[`KayKitGuideScenario`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenario/) | `undefined`

# describeKayKitGuideScenarioCoverage

> **describeKayKitGuideScenarioCoverage**(`id`): [`KayKitGuideScenarioCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenariocoverage/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:945](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L945)

Returns the scenario, page counts, and public treatment join for one guide page scenario.

## Parameters

[Section titled “Parameters”](#parameters)

### id

[Section titled “id”](#id)

`string`

## Returns

[Section titled “Returns”](#returns)

[`KayKitGuideScenarioCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenariocoverage/) | `undefined`

# factionBuildingAssetId

> **factionBuildingAssetId**(`kind`, `faction`): `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:788](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L788)

Builds a faction-colored building asset id.

## Parameters

[Section titled “Parameters”](#parameters)

### kind

[Section titled “kind”](#kind)

`"archeryrange"` | `"barracks"` | `"blacksmith"` | `"castle"` | `"church"` | `"docks"` | `"home_A"` | `"home_B"` | `"lumbermill"` | `"market"` | `"mine"` | `"shipyard"` | `"shrine"` | `"stables"` | `"tavern"` | `"tent"` | `"townhall"` | `"tower_A"` | `"tower_B"` | `"tower_base"` | `"tower_cannon"` | `"tower_catapult"` | `"watchtower"` | `"watermill"` | `"well"` | `"windmill"` | `"workshop"`

### faction

[Section titled “faction”](#faction)

`"blue"` | `"green"` | `"red"` | `"yellow"`

## Returns

[Section titled “Returns”](#returns)

`string`

# flagAssetId

> **flagAssetId**(`faction`): `"tent"` | `"anchor"` | `"barrel"` | `"boat"` | `"boatrack"` | `"bucket_arrows"` | `"bucket_empty"` | `"bucket_water"` | `"cannonball_pallet"` | `"crate_A_big"` | `"crate_A_small"` | `"crate_B_big"` | `"crate_B_small"` | `"crate_long_A"` | `"crate_long_B"` | `"crate_long_C"` | `"crate_long_empty"` | `"crate_open"` | `"flag_blue"` | `"flag_green"` | `"flag_red"` | `"flag_yellow"` | `"haybale"` | `"icon_combat"` | `"icon_range"` | `"ladder"` | `"pallet"` | `"resource_lumber"` | `"resource_stone"` | `"sack"` | `"target"` | `"trough"` | `"trough_long"` | `"weaponrack"` | `"wheelbarrow"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:1275](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L1275)

Builds a faction flag prop asset id.

## Parameters

[Section titled “Parameters”](#parameters)

### faction

[Section titled “faction”](#faction)

`"blue"` | `"green"` | `"red"` | `"yellow"`

## Returns

[Section titled “Returns”](#returns)

`"tent"` | `"anchor"` | `"barrel"` | `"boat"` | `"boatrack"` | `"bucket_arrows"` | `"bucket_empty"` | `"bucket_water"` | `"cannonball_pallet"` | `"crate_A_big"` | `"crate_A_small"` | `"crate_B_big"` | `"crate_B_small"` | `"crate_long_A"` | `"crate_long_B"` | `"crate_long_C"` | `"crate_long_empty"` | `"crate_open"` | `"flag_blue"` | `"flag_green"` | `"flag_red"` | `"flag_yellow"` | `"haybale"` | `"icon_combat"` | `"icon_range"` | `"ladder"` | `"pallet"` | `"resource_lumber"` | `"resource_stone"` | `"sack"` | `"target"` | `"trough"` | `"trough_long"` | `"weaponrack"` | `"wheelbarrow"`

# hasKayKitAssetTreatment

> **hasKayKitAssetTreatment**(`assetId`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:1244](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L1244)

Returns whether an asset id has an explicit public API treatment.

## Parameters

[Section titled “Parameters”](#parameters)

### assetId

[Section titled “assetId”](#assetid)

`string`

## Returns

[Section titled “Returns”](#returns)

`boolean`

# isFaction

> **isFaction**(`value`): value is “blue” | “green” | “red” | “yellow”

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:1294](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L1294)

Type guard for supported faction ids.

## Parameters

[Section titled “Parameters”](#parameters)

### value

[Section titled “value”](#value)

`string`

## Returns

[Section titled “Returns”](#returns)

value is “blue” | “green” | “red” | “yellow”

# isKnownExtraAssetId

> **isKnownExtraAssetId**(`assetId`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:1270](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L1270)

Checks whether an asset id belongs to known local-only EXTRA content.

## Parameters

[Section titled “Parameters”](#parameters)

### assetId

[Section titled “assetId”](#assetid)

`string`

## Returns

[Section titled “Returns”](#returns)

`boolean`

# isTextureSet

> **isTextureSet**(`value`): value is “default” | “fall” | “summer” | “winter”

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:1299](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L1299)

Type guard for supported KayKit texture set ids.

## Parameters

[Section titled “Parameters”](#parameters)

### value

[Section titled “value”](#value)

`string`

## Returns

[Section titled “Returns”](#returns)

value is “default” | “fall” | “summer” | “winter”

# isUnitStyle

> **isUnitStyle**(`value`): value is “neutral” | “accent” | “full”

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:1304](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L1304)

Type guard for supported colored unit styles.

## Parameters

[Section titled “Parameters”](#parameters)

### value

[Section titled “value”](#value)

`string`

## Returns

[Section titled “Returns”](#returns)

value is “neutral” | “accent” | “full”

# listKayKitAssetPublicTreatments

> **listKayKitAssetPublicTreatments**(): [`KayKitAssetPublicTreatment`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitassetpublictreatment/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:810](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L810)

Lists the public treatment contract for every FREE and local EXTRA KayKit asset id.

## Returns

[Section titled “Returns”](#returns)

[`KayKitAssetPublicTreatment`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitassetpublictreatment/)\[]

# listKayKitGuideAssetCoverages

> **listKayKitGuideAssetCoverages**(): [`KayKitGuideAssetCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguideassetcoverage/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:993](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L993)

Lists every public asset id and the guide pages/APIs/docs/visuals that exercise it.

## Returns

[Section titled “Returns”](#returns)

[`KayKitGuideAssetCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguideassetcoverage/)\[]

# listKayKitGuidePublicApiCoverages

> **listKayKitGuidePublicApiCoverages**(): [`KayKitGuidePublicApiCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidepublicapicoverage/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:959](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L959)

Lists public API surfaces and the guide pages/assets that intentionally exercise them.

## Returns

[Section titled “Returns”](#returns)

[`KayKitGuidePublicApiCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidepublicapicoverage/)\[]

# listKayKitGuideRoleCoverages

> **listKayKitGuideRoleCoverages**(): [`KayKitGuideRoleCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguiderolecoverage/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:977](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L977)

Lists public asset roles and the guide pages/assets/APIs that intentionally exercise them.

## Returns

[Section titled “Returns”](#returns)

[`KayKitGuideRoleCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguiderolecoverage/)\[]

# listKayKitGuideScenarioAssetRenderGroups

> **listKayKitGuideScenarioAssetRenderGroups**(`options?`): [`KayKitGuideScenarioAssetRenderGroup`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetrendergroup/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:914](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L914)

Groups renderer-ready guide asset requests by extracted guide scenario.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`KayKitGuideScenarioAssetRenderRequestOptions`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetrenderrequestoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`KayKitGuideScenarioAssetRenderGroup`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetrendergroup/)\[]

# listKayKitGuideScenarioAssetRenderRequests

> **listKayKitGuideScenarioAssetRenderRequests**(`options?`): [`KayKitGuideScenarioAssetRenderRequest`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetrenderrequest/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:904](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L904)

Lists renderer-ready guide asset requests with optional URL resolution.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`KayKitGuideScenarioAssetRenderRequestOptions`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetrenderrequestoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`KayKitGuideScenarioAssetRenderRequest`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetrenderrequest/)\[]

# listKayKitGuideScenarioAssetUsages

> **listKayKitGuideScenarioAssetUsages**(`options?`): [`KayKitGuideScenarioAssetUsage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusage/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:843](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L843)

Lists page-level guide asset occurrences as renderer-ready public treatment records.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`KayKitGuideScenarioAssetUsageOptions`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`KayKitGuideScenarioAssetUsage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusage/)\[]

# listKayKitGuideScenarioAssetUsagesForScenario

> **listKayKitGuideScenarioAssetUsagesForScenario**(`id`, `options?`): [`KayKitGuideScenarioAssetUsage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusage/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:896](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L896)

Lists renderer-ready guide asset occurrences for one scenario id.

## Parameters

[Section titled “Parameters”](#parameters)

### id

[Section titled “id”](#id)

`string`

### options?

[Section titled “options?”](#options)

`Omit`<[`KayKitGuideScenarioAssetUsageOptions`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/), `"scenarioIds"`> = `{}`

## Returns

[Section titled “Returns”](#returns)

[`KayKitGuideScenarioAssetUsage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusage/)\[]

# listKayKitGuideScenarios

> **listKayKitGuideScenarios**(): [`KayKitGuideScenario`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenario/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:815](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L815)

Lists the decomposed scenario contract for every extracted KayKit guide page.

## Returns

[Section titled “Returns”](#returns)

[`KayKitGuideScenario`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenario/)\[]

# listKayKitGuideScenarioTreatments

> **listKayKitGuideScenarioTreatments**(`id`): [`KayKitAssetPublicTreatment`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitassetpublictreatment/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:832](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L832)

Returns public treatment records for the assets used by one guide scenario.

## Parameters

[Section titled “Parameters”](#parameters)

### id

[Section titled “id”](#id)

`string`

## Returns

[Section titled “Returns”](#returns)

[`KayKitAssetPublicTreatment`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitassetpublictreatment/)\[]

# neutralUnitAssetId

> **neutralUnitAssetId**(`part`): `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:802](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L802)

Returns the neutral unit/equipment asset id for a part.

## Parameters

[Section titled “Parameters”](#parameters)

### part

[Section titled “part”](#part)

`"banner"` | `"bow"` | `"cannon"` | `"cart"` | `"cart_merchant"` | `"catapult"` | `"helmet"` | `"projectile_arrow"` | `"shield"` | `"ship"` | `"spear"` | `"sword"` | `"unit"` | `"hammer"` | `"horse_A"` | `"horse_B"` | `"horse_C"` | `"horse_D"` | `"horse_E"` | `"horse_F"` | `"horse_G"` | `"horse_saddle"` | `"projectile_cannonball"` | `"projectile_catapult"` | `"shovel"`

## Returns

[Section titled “Returns”](#returns)

`string`

# renderKayKitGuideScenarioCoverageMarkdown

> **renderKayKitGuideScenarioCoverageMarkdown**(`options?`): `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:1058](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L1058)

Renders the guide scenario coverage matrix as reproducible Markdown docs.

## Parameters

[Section titled “Parameters”](#parameters)

### options?

[Section titled “options?”](#options)

[`KayKitGuideScenarioCoverageMarkdownOptions`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenariocoveragemarkdownoptions/) = `{}`

## Returns

[Section titled “Returns”](#returns)

`string`

# summarizeKayKitGuideCoverage

> **summarizeKayKitGuideCoverage**(): [`KayKitGuideCoverageSummary`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidecoveragesummary/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:1018](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L1018)

Summarizes source images, docs, visual artifacts, assets, roles, and page coverage.

## Returns

[Section titled “Returns”](#returns)

[`KayKitGuideCoverageSummary`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidecoveragesummary/)

# textureFileName

> **textureFileName**(`textureSet`): `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:1280](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L1280)

Returns the texture filename for a KayKit texture set.

## Parameters

[Section titled “Parameters”](#parameters)

### textureSet

[Section titled “textureSet”](#textureset)

`"default"` | `"fall"` | `"summer"` | `"winter"`

## Returns

[Section titled “Returns”](#returns)

`string`

# KayKitAssetPublicTreatment

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:412](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L412)

Public API treatment for one asset id. This is the contract that keeps assets from becoming a passive catalog entry with no builder, selector, or layout path.

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:414](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L414)

Stable manifest asset id used by plans and placement records.

***

### category

[Section titled “category”](#category)

> **category**: `"tiles"` | `"buildings"` | `"decoration"` | `"units"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:418](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L418)

Top-level manifest category.

***

### minimumEdition

[Section titled “minimumEdition”](#minimumedition)

> **minimumEdition**: `"free"` | `"extra"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:416](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L416)

Lowest edition that exposes this asset id.

***

### placementKind

[Section titled “placementKind”](#placementkind)

> **placementKind**: `"coast"` | `"road"` | `"river"` | `"unit"` | `"decoration"` | `"prop"` | `"terrain"` | `"transition"` | `"structure"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:426](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L426)

Placement kind produced by the public board/runtime APIs.

***

### placementLayer

[Section titled “placementLayer”](#placementlayer)

> **placementLayer**: `"unit"` | `"terrain"` | `"structure"` | `"surface"` | `"feature"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:437](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L437)

Placement layer produced by the public board/runtime APIs.

***

### publicApi

[Section titled “publicApi”](#publicapi)

> **publicApi**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:439](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L439)

Public helpers or selectors that intentionally exercise this asset.

***

### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:445](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L445)

Whether this asset should be treated as local-only/EXTRA in apps.

***

### role

[Section titled “role”](#role)

> **role**: [`KayKitAssetPublicRole`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitassetpublicrole/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:424](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L424)

Intent-level role used by docs, selectors, and gameplay placement helpers.

***

### scenario

[Section titled “scenario”](#scenario)

> **scenario**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:443](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L443)

Human-readable scenario group for visual contact sheets and docs.

***

### sourceImages

[Section titled “sourceImages”](#sourceimages)

> **sourceImages**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:441](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L441)

Extracted guide images that motivate this treatment.

***

### sourcePath

[Section titled “sourcePath”](#sourcepath)

> **sourcePath**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:422](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L422)

Source-relative GLTF path for FREE packaging or local EXTRA ingest.

***

### subcategory

[Section titled “subcategory”](#subcategory)

> **subcategory**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:420](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L420)

Manifest subcategory or source folder.

# KayKitGuideAssetCoverage

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:601](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L601)

Coverage record that maps one asset id back to guide pages, APIs, docs, and visuals.

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:603](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L603)

Stable manifest asset id used by plans and placement records.

***

### category

[Section titled “category”](#category)

> **category**: `"tiles"` | `"buildings"` | `"decoration"` | `"units"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:607](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L607)

Top-level manifest category.

***

### docs

[Section titled “docs”](#docs)

> **docs**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:631](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L631)

Documentation pages linked by the matching guide scenarios.

***

### editions

[Section titled “editions”](#editions)

> **editions**: readonly [`KayKitGuideScenarioEdition`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitguidescenarioedition/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:625](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L625)

Edition scopes represented by the guide scenarios.

***

### minimumEdition

[Section titled “minimumEdition”](#minimumedition)

> **minimumEdition**: `"free"` | `"extra"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:605](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L605)

Lowest edition that exposes this asset id.

***

### occurrences

[Section titled “occurrences”](#occurrences)

> **occurrences**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:635](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L635)

Number of page-level scenario references for this asset id.

***

### pages

[Section titled “pages”](#pages)

> **pages**: readonly `number`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:623](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L623)

One-based extracted guide pages that exercise this asset id.

***

### placementKind

[Section titled “placementKind”](#placementkind)

> **placementKind**: `"coast"` | `"road"` | `"river"` | `"unit"` | `"decoration"` | `"prop"` | `"terrain"` | `"transition"` | `"structure"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:615](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L615)

Placement kind produced by the public board/runtime APIs.

***

### placementLayer

[Section titled “placementLayer”](#placementlayer)

> **placementLayer**: `"unit"` | `"terrain"` | `"structure"` | `"surface"` | `"feature"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:617](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L617)

Placement layer produced by the public board/runtime APIs.

***

### publicApi

[Section titled “publicApi”](#publicapi)

> **publicApi**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:629](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L629)

Public helper/API entries attached to this asset id.

***

### role

[Section titled “role”](#role)

> **role**: [`KayKitAssetPublicRole`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitassetpublicrole/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:613](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L613)

Intent-level role used by docs, selectors, and gameplay placement helpers.

***

### scenarioIds

[Section titled “scenarioIds”](#scenarioids)

> **scenarioIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:621](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L621)

Guide scenario ids that explicitly reference this asset id.

***

### sourceImages

[Section titled “sourceImages”](#sourceimages)

> **sourceImages**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:627](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L627)

Extracted guide source PNGs that reference or motivate this asset id.

***

### sourcePath

[Section titled “sourcePath”](#sourcepath)

> **sourcePath**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:611](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L611)

Source-relative GLTF path for FREE packaging or local EXTRA ingest.

***

### subcategory

[Section titled “subcategory”](#subcategory)

> **subcategory**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:609](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L609)

Manifest subcategory or source folder.

***

### treatment

[Section titled “treatment”](#treatment)

> **treatment**: [`KayKitAssetPublicTreatment`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitassetpublictreatment/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:619](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L619)

Full public treatment record for this asset id.

***

### visualArtifacts

[Section titled “visualArtifacts”](#visualartifacts)

> **visualArtifacts**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:633](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L633)

Visual artifacts linked by the matching guide scenarios.

# KayKitGuideAssetCoverageCounts

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:481](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L481)

Coverage counts for KayKit guide assets by unique id and page occurrence.

## Properties

[Section titled “Properties”](#properties)

### extra

[Section titled “extra”](#extra)

> **extra**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:487](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L487)

Unique EXTRA asset ids referenced by the guide scenario matrix.

***

### extraOccurrences

[Section titled “extraOccurrences”](#extraoccurrences)

> **extraOccurrences**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:493](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L493)

EXTRA scenario asset references, counting repeated page-level use.

***

### free

[Section titled “free”](#free)

> **free**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:485](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L485)

Unique FREE asset ids referenced by the guide scenario matrix.

***

### freeOccurrences

[Section titled “freeOccurrences”](#freeoccurrences)

> **freeOccurrences**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:491](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L491)

FREE scenario asset references, counting repeated page-level use.

***

### occurrences

[Section titled “occurrences”](#occurrences)

> **occurrences**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:489](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L489)

Total scenario asset references, counting repeated page-level use.

***

### unique

[Section titled “unique”](#unique)

> **unique**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:483](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L483)

Unique asset ids referenced by the guide scenario matrix.

# KayKitGuideCoverageSummary

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:521](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L521)

Summary of the full extracted KayKit guide scenario matrix.

## Properties

[Section titled “Properties”](#properties)

### assetCounts

[Section titled “assetCounts”](#assetcounts)

> **assetCounts**: [`KayKitGuideAssetCoverageCounts`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguideassetcoveragecounts/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:533](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L533)

Unique and occurrence asset coverage counts.

***

### docsCount

[Section titled “docsCount”](#docscount)

> **docsCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:531](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L531)

Number of distinct docs referenced by guide scenarios.

***

### pageCount

[Section titled “pageCount”](#pagecount)

> **pageCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:525](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L525)

Number of extracted guide pages.

***

### pages

[Section titled “pages”](#pages)

> **pages**: readonly [`KayKitGuidePageCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidepagecoverage/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:539](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L539)

Page-level coverage rows in guide order.

***

### scenarioCount

[Section titled “scenarioCount”](#scenariocount)

> **scenarioCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:523](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L523)

Number of guide scenarios.

***

### scenariosByEdition

[Section titled “scenariosByEdition”](#scenariosbyedition)

> **scenariosByEdition**: `Readonly`<`Record`<[`KayKitGuideScenarioEdition`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitguidescenarioedition/), `number`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:535](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L535)

Scenario counts by edition scope.

***

### sourceImageCount

[Section titled “sourceImageCount”](#sourceimagecount)

> **sourceImageCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:527](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L527)

Number of distinct source images referenced by guide scenarios.

***

### uniqueAssetsByRole

[Section titled “uniqueAssetsByRole”](#uniqueassetsbyrole)

> **uniqueAssetsByRole**: `Readonly`<`Partial`<`Record`<[`KayKitAssetPublicRole`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitassetpublicrole/), `number`>>>

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:537](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L537)

Unique asset counts by public treatment role.

***

### visualArtifactCount

[Section titled “visualArtifactCount”](#visualartifactcount)

> **visualArtifactCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:529](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L529)

Number of distinct visual artifacts referenced by guide scenarios.

# KayKitGuidePageCoverage

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:497](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L497)

Coverage record for one extracted KayKit guide page.

## Properties

[Section titled “Properties”](#properties)

### assetOccurrences

[Section titled “assetOccurrences”](#assetoccurrences)

> **assetOccurrences**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:505](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L505)

Asset references on this page, counting repeated use across pages.

***

### docs

[Section titled “docs”](#docs)

> **docs**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:517](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L517)

Documentation entries attached to this page.

***

### edition

[Section titled “edition”](#edition)

> **edition**: [`KayKitGuideScenarioEdition`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitguidescenarioedition/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:503](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L503)

Edition scope represented by this page.

***

### extraAssets

[Section titled “extraAssets”](#extraassets)

> **extraAssets**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:511](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L511)

EXTRA asset ids on this page.

***

### freeAssets

[Section titled “freeAssets”](#freeassets)

> **freeAssets**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:509](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L509)

FREE asset ids on this page.

***

### page

[Section titled “page”](#page)

> **page**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:499](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L499)

One-based extracted guide page number.

***

### publicApis

[Section titled “publicApis”](#publicapis)

> **publicApis**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:513](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L513)

Public helper/API entries attached to this page.

***

### scenarioId

[Section titled “scenarioId”](#scenarioid)

> **scenarioId**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:501](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L501)

Stable scenario id for the page.

***

### uniqueAssets

[Section titled “uniqueAssets”](#uniqueassets)

> **uniqueAssets**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:507](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L507)

Unique asset ids on this page.

***

### visualArtifacts

[Section titled “visualArtifacts”](#visualartifacts)

> **visualArtifacts**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:515](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L515)

Review artifacts attached to this page.

# KayKitGuidePublicApiCoverage

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:557](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L557)

Coverage record that maps one public API surface back to guide pages and assets.

## Properties

[Section titled “Properties”](#properties)

### assetCounts

[Section titled “assetCounts”](#assetcounts)

> **assetCounts**: [`KayKitGuideAssetCoverageCounts`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguideassetcoveragecounts/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:571](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L571)

Unique and repeated asset counts for this API surface across matching guide pages.

***

### assetIds

[Section titled “assetIds”](#assetids)

> **assetIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:567](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L567)

Asset ids whose treatment explicitly lists this API surface.

***

### docs

[Section titled “docs”](#docs)

> **docs**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:573](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L573)

Documentation pages linked by the matching guide scenarios.

***

### editions

[Section titled “editions”](#editions)

> **editions**: readonly [`KayKitGuideScenarioEdition`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitguidescenarioedition/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:565](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L565)

Edition scopes represented by the guide scenarios.

***

### pages

[Section titled “pages”](#pages)

> **pages**: readonly `number`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:563](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L563)

One-based extracted guide pages that exercise this API surface.

***

### publicApi

[Section titled “publicApi”](#publicapi)

> **publicApi**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:559](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L559)

Public builder, selector, CLI, manifest, docs, or runtime surface.

***

### scenarioIds

[Section titled “scenarioIds”](#scenarioids)

> **scenarioIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:561](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L561)

Guide scenario ids that list or inherit this public API surface.

***

### treatmentRoles

[Section titled “treatmentRoles”](#treatmentroles)

> **treatmentRoles**: readonly [`KayKitAssetPublicRole`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitassetpublicrole/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:569](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L569)

Public treatment roles attached to those assets.

***

### visualArtifacts

[Section titled “visualArtifacts”](#visualartifacts)

> **visualArtifacts**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:575](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L575)

Visual artifacts linked by the matching guide scenarios.

# KayKitGuideRoleCoverage

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:579](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L579)

Coverage record that maps one public asset role back to guide pages, APIs, and assets.

## Properties

[Section titled “Properties”](#properties)

### assetCounts

[Section titled “assetCounts”](#assetcounts)

> **assetCounts**: [`KayKitGuideAssetCoverageCounts`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguideassetcoveragecounts/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:593](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L593)

Unique and repeated asset counts for this role across matching guide pages.

***

### assetIds

[Section titled “assetIds”](#assetids)

> **assetIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:589](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L589)

Asset ids whose treatment uses this role.

***

### docs

[Section titled “docs”](#docs)

> **docs**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:595](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L595)

Documentation pages linked by the matching guide scenarios.

***

### editions

[Section titled “editions”](#editions)

> **editions**: readonly [`KayKitGuideScenarioEdition`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitguidescenarioedition/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:587](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L587)

Edition scopes represented by the guide scenarios.

***

### pages

[Section titled “pages”](#pages)

> **pages**: readonly `number`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:585](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L585)

One-based extracted guide pages that exercise this role.

***

### publicApi

[Section titled “publicApi”](#publicapi)

> **publicApi**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:591](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L591)

Public helper/API entries attached to assets with this role.

***

### role

[Section titled “role”](#role)

> **role**: [`KayKitAssetPublicRole`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitassetpublicrole/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:581](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L581)

Public treatment role assigned to the covered asset group.

***

### scenarioIds

[Section titled “scenarioIds”](#scenarioids)

> **scenarioIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:583](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L583)

Guide scenario ids that list or inherit this public role.

***

### visualArtifacts

[Section titled “visualArtifacts”](#visualartifacts)

> **visualArtifacts**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:597](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L597)

Visual artifacts linked by the matching guide scenarios.

# KayKitGuideScenario

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:455](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L455)

Decomposed scenario contract for one extracted KayKit guide page. Scenarios connect the image page to assets, public APIs, visual artifacts, and docs.

## Properties

[Section titled “Properties”](#properties)

### assetIds

[Section titled “assetIds”](#assetids)

> **assetIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:469](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L469)

Asset ids that must be exercised for this page/use case.

***

### docs

[Section titled “docs”](#docs)

> **docs**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:477](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L477)

Documentation pages that explain the public contract.

***

### edition

[Section titled “edition”](#edition)

> **edition**: [`KayKitGuideScenarioEdition`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitguidescenarioedition/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:465](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L465)

Edition scope for the use case shown by the page.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:457](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L457)

Stable scenario id derived from the guide page and use case.

***

### page

[Section titled “page”](#page)

> **page**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:459](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L459)

One-based extracted guide page number.

***

### publicApi

[Section titled “publicApi”](#publicapi)

> **publicApi**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:471](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L471)

Public helper surfaces that express this guide page.

***

### sourceImage

[Section titled “sourceImage”](#sourceimage)

> **sourceImage**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:463](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L463)

Extracted PNG page used as source material.

***

### summary

[Section titled “summary”](#summary)

> **summary**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:467](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L467)

Concise implementation intent for humans, tests, and agents.

***

### title

[Section titled “title”](#title)

> **title**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:461](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L461)

Human-readable guide page title.

***

### treatmentRoles

[Section titled “treatmentRoles”](#treatmentroles)

> **treatmentRoles**: readonly [`KayKitAssetPublicRole`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitassetpublicrole/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:473](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L473)

Public treatment roles represented by this page.

***

### visualArtifacts

[Section titled “visualArtifacts”](#visualartifacts)

> **visualArtifacts**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:475](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L475)

Screenshot or docs artifacts that should be reviewed for this page.

# KayKitGuideScenarioAssetRenderGroup

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:758](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L758)

Render-request group for one extracted guide scenario.

## Properties

[Section titled “Properties”](#properties)

### count

[Section titled “count”](#count)

> **count**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:772](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L772)

Number of repeated asset occurrences in this group.

***

### edition

[Section titled “edition”](#edition)

> **edition**: [`KayKitGuideScenarioEdition`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitguidescenarioedition/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:768](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L768)

Scenario edition scope.

***

### page

[Section titled “page”](#page)

> **page**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:762](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L762)

One-based extracted guide page number.

***

### requests

[Section titled “requests”](#requests)

> **requests**: readonly [`KayKitGuideScenarioAssetRenderRequest`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetrenderrequest/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:770](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L770)

Renderer-ready asset requests for this page.

***

### scenarioId

[Section titled “scenarioId”](#scenarioid)

> **scenarioId**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:760](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L760)

Stable scenario id.

***

### sourceImage

[Section titled “sourceImage”](#sourceimage)

> **sourceImage**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:766](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L766)

Extracted PNG page used as source material.

***

### title

[Section titled “title”](#title)

> **title**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:764](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L764)

Human-readable guide page title.

# KayKitGuideScenarioAssetRenderRequest

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:724](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L724)

Renderer-facing row for one guide asset occurrence. It keeps the original usage row attached while exposing the repeated fields renderers usually need.

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:734](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L734)

Stable manifest asset id used by renderers and placement records.

***

### caption

[Section titled “caption”](#caption)

> **caption**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:752](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L752)

Stable short caption for contact sheets and renderer previews.

***

### category

[Section titled “category”](#category)

> **category**: `"tiles"` | `"buildings"` | `"decoration"` | `"units"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:740](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L740)

Top-level manifest category.

***

### label

[Section titled “label”](#label)

> **label**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:750](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L750)

Stable short label for contact sheets and renderer previews.

***

### minimumEdition

[Section titled “minimumEdition”](#minimumedition)

> **minimumEdition**: `"free"` | `"extra"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:744](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L744)

Lowest edition that exposes this asset id.

***

### page

[Section titled “page”](#page)

> **page**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:728](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L728)

One-based extracted guide page number.

***

### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:746](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L746)

Whether this request requires local-only EXTRA assets.

***

### role

[Section titled “role”](#role)

> **role**: [`KayKitAssetPublicRole`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitassetpublicrole/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:748](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L748)

Intent-level role used by docs, selectors, and gameplay placement helpers.

***

### scenarioId

[Section titled “scenarioId”](#scenarioid)

> **scenarioId**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:726](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L726)

Stable scenario id that introduced this render request.

***

### sourceImage

[Section titled “sourceImage”](#sourceimage)

> **sourceImage**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:732](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L732)

Extracted PNG page used as source material.

***

### sourcePath

[Section titled “sourcePath”](#sourcepath)

> **sourcePath**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:736](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L736)

Source-relative GLTF path for FREE packaging or local EXTRA ingest.

***

### subcategory

[Section titled “subcategory”](#subcategory)

> **subcategory**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:742](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L742)

Manifest subcategory or source folder.

***

### title

[Section titled “title”](#title)

> **title**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:730](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L730)

Human-readable guide page title.

***

### url?

[Section titled “url?”](#url)

> `optional` **url?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:738](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L738)

Optional resolved URL for loading the GLTF.

***

### usage

[Section titled “usage”](#usage)

> **usage**: [`KayKitGuideScenarioAssetUsage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusage/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:754](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L754)

Original page-level usage row.

# KayKitGuideScenarioAssetRenderRequestOptions

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:712](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L712)

Options for creating renderer-facing guide asset requests.

## Extends

[Section titled “Extends”](#extends)

* [`KayKitGuideScenarioAssetUsageOptions`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/)

## Properties

[Section titled “Properties”](#properties)

### assetBaseUrl?

[Section titled “assetBaseUrl?”](#assetbaseurl)

> `optional` **assetBaseUrl?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:715](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L715)

Base URL/path prepended to each source-relative GLTF path.

***

### assetIds?

[Section titled “assetIds?”](#assetids)

> `optional` **assetIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:697](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L697)

Limit usages to exact asset ids.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`KayKitGuideScenarioAssetUsageOptions`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/).[`assetIds`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/#assetids)

***

### categories?

[Section titled “categories?”](#categories)

> `optional` **categories?**: readonly (`"tiles"` | `"buildings"` | `"decoration"` | `"units"`)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:701](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L701)

Limit usages by top-level manifest categories.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`KayKitGuideScenarioAssetUsageOptions`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/).[`categories`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/#categories)

***

### editionScope?

[Section titled “editionScope?”](#editionscope)

> `optional` **editionScope?**: [`KayKitGuideScenarioEdition`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitguidescenarioedition/) | readonly [`KayKitGuideScenarioEdition`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitguidescenarioedition/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:693](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L693)

Limit usages by the guide scenario edition scope.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`KayKitGuideScenarioAssetUsageOptions`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/).[`editionScope`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/#editionscope)

***

### minimumEdition?

[Section titled “minimumEdition?”](#minimumedition)

> `optional` **minimumEdition?**: `"free"` | `"extra"` | `"all"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:695](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L695)

Limit usages by the asset’s lowest available edition; defaults to all.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`KayKitGuideScenarioAssetUsageOptions`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/).[`minimumEdition`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/#minimumedition)

***

### pages?

[Section titled “pages?”](#pages)

> `optional` **pages?**: readonly `number`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:691](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L691)

Limit usages to one-based guide pages.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`KayKitGuideScenarioAssetUsageOptions`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/).[`pages`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/#pages)

***

### publicApis?

[Section titled “publicApis?”](#publicapis)

> `optional` **publicApis?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:703](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L703)

Limit usages by public helper/API entries attached to the asset treatment.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`KayKitGuideScenarioAssetUsageOptions`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/).[`publicApis`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/#publicapis)

***

### roles?

[Section titled “roles?”](#roles)

> `optional` **roles?**: readonly [`KayKitAssetPublicRole`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitassetpublicrole/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:699](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L699)

Limit usages by public treatment roles.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`KayKitGuideScenarioAssetUsageOptions`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/).[`roles`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/#roles)

***

### scenarioIds?

[Section titled “scenarioIds?”](#scenarioids)

> `optional` **scenarioIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:689](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L689)

Limit usages to exact scenario ids.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`KayKitGuideScenarioAssetUsageOptions`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/).[`scenarioIds`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusageoptions/#scenarioids)

***

### urlResolver?

[Section titled “urlResolver?”](#urlresolver)

> `optional` **urlResolver?**: [`KayKitGuideScenarioAssetUrlResolver`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitguidescenarioasseturlresolver/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:717](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L717)

Custom URL resolver, used before `assetBaseUrl` when provided.

# KayKitGuideScenarioAssetUsage

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:643](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L643)

Page-level asset occurrence from the decomposed KayKit guide matrix. Unlike asset coverage rows, this keeps repeated scenario uses so renderers, screenshots, docs, and audits can reproduce the exact guide treatment set.

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:655](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L655)

Stable manifest asset id used by plans and placement records.

***

### caption

[Section titled “caption”](#caption)

> **caption**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:683](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L683)

Stable short caption for contact sheets and renderer previews.

***

### category

[Section titled “category”](#category)

> **category**: `"tiles"` | `"buildings"` | `"decoration"` | `"units"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:659](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L659)

Top-level manifest category.

***

### docs

[Section titled “docs”](#docs)

> **docs**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:673](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L673)

Documentation pages linked by the matching guide scenario.

***

### label

[Section titled “label”](#label)

> **label**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:681](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L681)

Stable short label for contact sheets and renderer previews.

***

### minimumEdition

[Section titled “minimumEdition”](#minimumedition)

> **minimumEdition**: `"free"` | `"extra"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:657](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L657)

Lowest edition that exposes this asset id.

***

### page

[Section titled “page”](#page)

> **page**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:647](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L647)

One-based extracted guide page number.

***

### placementKind

[Section titled “placementKind”](#placementkind)

> **placementKind**: `"coast"` | `"road"` | `"river"` | `"unit"` | `"decoration"` | `"prop"` | `"terrain"` | `"transition"` | `"structure"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:667](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L667)

Placement kind produced by the public board/runtime APIs.

***

### placementLayer

[Section titled “placementLayer”](#placementlayer)

> **placementLayer**: `"unit"` | `"terrain"` | `"structure"` | `"surface"` | `"feature"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:669](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L669)

Placement layer produced by the public board/runtime APIs.

***

### publicApi

[Section titled “publicApi”](#publicapi)

> **publicApi**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:671](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L671)

Public helpers or selectors that intentionally exercise this asset.

***

### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:679](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L679)

Whether this asset should be treated as local-only/EXTRA in apps.

***

### role

[Section titled “role”](#role)

> **role**: [`KayKitAssetPublicRole`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitassetpublicrole/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:665](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L665)

Intent-level role used by docs, selectors, and gameplay placement helpers.

***

### scenarioEdition

[Section titled “scenarioEdition”](#scenarioedition)

> **scenarioEdition**: [`KayKitGuideScenarioEdition`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitguidescenarioedition/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:653](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L653)

Edition scope for the source guide scenario.

***

### scenarioId

[Section titled “scenarioId”](#scenarioid)

> **scenarioId**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:645](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L645)

Stable scenario id that introduced this asset occurrence.

***

### sourceImage

[Section titled “sourceImage”](#sourceimage)

> **sourceImage**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:651](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L651)

Extracted PNG page used as source material.

***

### sourcePath

[Section titled “sourcePath”](#sourcepath)

> **sourcePath**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:663](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L663)

Source-relative GLTF path for FREE packaging or local EXTRA ingest.

***

### subcategory

[Section titled “subcategory”](#subcategory)

> **subcategory**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:661](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L661)

Manifest subcategory or source folder.

***

### title

[Section titled “title”](#title)

> **title**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:649](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L649)

Human-readable guide page title.

***

### treatment

[Section titled “treatment”](#treatment)

> **treatment**: [`KayKitAssetPublicTreatment`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitassetpublictreatment/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:677](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L677)

Full public treatment record for this asset id.

***

### visualArtifacts

[Section titled “visualArtifacts”](#visualartifacts)

> **visualArtifacts**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:675](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L675)

Screenshot or docs artifacts linked by the matching guide scenario.

# KayKitGuideScenarioAssetUsageOptions

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:687](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L687)

Filters for page-level KayKit guide asset usages.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`KayKitGuideScenarioAssetRenderRequestOptions`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetrenderrequestoptions/)

## Properties

[Section titled “Properties”](#properties)

### assetIds?

[Section titled “assetIds?”](#assetids)

> `optional` **assetIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:697](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L697)

Limit usages to exact asset ids.

***

### categories?

[Section titled “categories?”](#categories)

> `optional` **categories?**: readonly (`"tiles"` | `"buildings"` | `"decoration"` | `"units"`)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:701](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L701)

Limit usages by top-level manifest categories.

***

### editionScope?

[Section titled “editionScope?”](#editionscope)

> `optional` **editionScope?**: [`KayKitGuideScenarioEdition`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitguidescenarioedition/) | readonly [`KayKitGuideScenarioEdition`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitguidescenarioedition/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:693](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L693)

Limit usages by the guide scenario edition scope.

***

### minimumEdition?

[Section titled “minimumEdition?”](#minimumedition)

> `optional` **minimumEdition?**: `"free"` | `"extra"` | `"all"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:695](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L695)

Limit usages by the asset’s lowest available edition; defaults to all.

***

### pages?

[Section titled “pages?”](#pages)

> `optional` **pages?**: readonly `number`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:691](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L691)

Limit usages to one-based guide pages.

***

### publicApis?

[Section titled “publicApis?”](#publicapis)

> `optional` **publicApis?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:703](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L703)

Limit usages by public helper/API entries attached to the asset treatment.

***

### roles?

[Section titled “roles?”](#roles)

> `optional` **roles?**: readonly [`KayKitAssetPublicRole`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/kaykitassetpublicrole/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:699](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L699)

Limit usages by public treatment roles.

***

### scenarioIds?

[Section titled “scenarioIds?”](#scenarioids)

> `optional` **scenarioIds?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:689](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L689)

Limit usages to exact scenario ids.

# KayKitGuideScenarioCoverage

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:543](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L543)

Public treatment join for one extracted KayKit guide scenario.

## Properties

[Section titled “Properties”](#properties)

### assetCounts

[Section titled “assetCounts”](#assetcounts)

> **assetCounts**: [`KayKitGuideAssetCoverageCounts`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguideassetcoveragecounts/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:549](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L549)

Unique and occurrence counts scoped to this scenario.

***

### missingTreatmentAssetIds

[Section titled “missingTreatmentAssetIds”](#missingtreatmentassetids)

> **missingTreatmentAssetIds**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:553](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L553)

Scenario asset ids that do not have a known public treatment.

***

### page

[Section titled “page”](#page)

> **page**: [`KayKitGuidePageCoverage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidepagecoverage/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:547](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L547)

Page-level coverage counts for this scenario.

***

### scenario

[Section titled “scenario”](#scenario)

> **scenario**: [`KayKitGuideScenario`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenario/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:545](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L545)

Decomposed guide scenario metadata.

***

### treatments

[Section titled “treatments”](#treatments)

> **treatments**: readonly [`KayKitAssetPublicTreatment`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitassetpublictreatment/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:551](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L551)

Public treatment records for the scenario assets.

# KayKitGuideScenarioCoverageMarkdownOptions

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:776](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L776)

Options for rendering the extracted guide scenario matrix as Markdown.

## Properties

[Section titled “Properties”](#properties)

### includePublicApiInversion?

[Section titled “includePublicApiInversion?”](#includepublicapiinversion)

> `optional` **includePublicApiInversion?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:784](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L784)

Whether to append the public API inverse-coverage usage section.

***

### includeRoleCoverage?

[Section titled “includeRoleCoverage?”](#includerolecoverage)

> `optional` **includeRoleCoverage?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:782](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L782)

Whether to append the public role coverage index.

***

### scenarios?

[Section titled “scenarios?”](#scenarios)

> `optional` **scenarios?**: readonly [`KayKitGuideScenario`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenario/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:780](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L780)

Scenario subset to render; defaults to all extracted guide scenarios.

***

### title?

[Section titled “title?”](#title)

> `optional` **title?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:778](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L778)

Heading used for the generated document.

# BaseTileAssetId

> **BaseTileAssetId** = *typeof* [`BASE_TILE_ASSET_IDS`](/declarative-hex-worlds/reference/scenario/catalog/variables/base_tile_asset_ids/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:374](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L374)

Base or support tile asset id.

# CoastTileAssetId

> **CoastTileAssetId** = \`hex\_coast\_${“A” | “B” | “C” | “D” | “E”}${“” | “\_waterless”}\`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:380](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L380)

Coast or waterless coast tile asset id.

# ColoredUnitPart

> **ColoredUnitPart** = *typeof* [`COLORED_UNIT_PARTS`](/declarative-hex-worlds/reference/scenario/catalog/variables/colored_unit_parts/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:366](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L366)

Faction-colored unit part id.

# ColoredUnitStyle

> **ColoredUnitStyle** = *typeof* [`EXTRA_UNIT_STYLES`](/declarative-hex-worlds/reference/scenario/catalog/variables/extra_unit_styles/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:370](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L370)

Colored unit style id.

# ExtraFactionBuildingKind

> **ExtraFactionBuildingKind** = *typeof* [`EXTRA_FACTION_BUILDING_KINDS`](/declarative-hex-worlds/reference/scenario/catalog/variables/extra_faction_building_kinds/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:358](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L358)

EXTRA-only faction building kind.

# ExtraTransitionTileAssetId

> **ExtraTransitionTileAssetId** = *typeof* [`EXTRA_TRANSITION_TILE_ASSET_IDS`](/declarative-hex-worlds/reference/scenario/catalog/variables/extra_transition_tile_asset_ids/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:376](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L376)

EXTRA-only transition tile asset id.

# FactionBuildingKind

> **FactionBuildingKind** = *typeof* [`FACTION_BUILDING_KINDS`](/declarative-hex-worlds/reference/scenario/catalog/variables/faction_building_kinds/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:354](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L354)

Any faction building kind supported by catalog helpers.

# FreeFactionBuildingKind

> **FreeFactionBuildingKind** = *typeof* [`FREE_FACTION_BUILDING_KINDS`](/declarative-hex-worlds/reference/scenario/catalog/variables/free_faction_building_kinds/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:356](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L356)

FREE faction building kind.

# KayKitAssetPublicRole

> **KayKitAssetPublicRole** = `"base-tile"` | `"support-tile"` | `"road-tile"` | `"river-tile"` | `"coast-tile"` | `"transition-tile"` | `"faction-building"` | `"neutral-structure"` | `"nature-decoration"` | `"prop"` | `"colored-unit-part"` | `"neutral-unit-part"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:394](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L394)

Public treatment role assigned to every KayKit Medieval Hexagon asset.

# KayKitGuideScenarioAssetUrlResolver

> **KayKitGuideScenarioAssetUrlResolver** = (`usage`) => `string` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:707](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L707)

Resolves a guide usage row to an app, package, or local reference URL.

## Parameters

[Section titled “Parameters”](#parameters)

### usage

[Section titled “usage”](#usage)

[`KayKitGuideScenarioAssetUsage`](/declarative-hex-worlds/reference/scenario/catalog/interfaces/kaykitguidescenarioassetusage/)

## Returns

[Section titled “Returns”](#returns)

`string` | `undefined`

# KayKitGuideScenarioEdition

> **KayKitGuideScenarioEdition** = [`PackEdition`](/declarative-hex-worlds/reference/types/type-aliases/packedition/) | `"mixed"` | `"reference"`

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:449](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L449)

Edition scope for an extracted KayKit guide-page scenario.

# KayKitTileAssetId

> **KayKitTileAssetId** = [`BaseTileAssetId`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/basetileassetid/) | [`ExtraTransitionTileAssetId`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/extratransitiontileassetid/) | [`RoadTileAssetId`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/roadtileassetid/) | [`CoastTileAssetId`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/coasttileassetid/) | [`RiverTileAssetId`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/rivertileassetid/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:384](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L384)

Tile asset id covered by guide-derived helpers.

# NatureAssetId

> **NatureAssetId** = *typeof* [`NATURE_ASSET_IDS`](/declarative-hex-worlds/reference/scenario/catalog/variables/nature_asset_ids/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:362](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L362)

Nature asset id.

# NeutralStructureKind

> **NeutralStructureKind** = *typeof* [`NEUTRAL_STRUCTURE_KINDS`](/declarative-hex-worlds/reference/scenario/catalog/variables/neutral_structure_kinds/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:360](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L360)

Neutral structure kind.

# NeutralUnitPart

> **NeutralUnitPart** = *typeof* [`NEUTRAL_UNIT_PARTS`](/declarative-hex-worlds/reference/scenario/catalog/variables/neutral_unit_parts/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:368](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L368)

Neutral unit part id.

# PropAssetId

> **PropAssetId** = *typeof* [`PROP_ASSET_IDS`](/declarative-hex-worlds/reference/scenario/catalog/variables/prop_asset_ids/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:364](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L364)

Prop asset id.

# RiverTileAssetId

> **RiverTileAssetId** = *typeof* [`RIVER_TILE_ASSET_IDS`](/declarative-hex-worlds/reference/scenario/catalog/variables/river_tile_asset_ids/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:382](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L382)

River, crossing, curvy, or waterless river tile asset id.

# RoadTileAssetId

> **RoadTileAssetId** = *typeof* [`ROAD_TILE_ASSET_IDS`](/declarative-hex-worlds/reference/scenario/catalog/variables/road_tile_asset_ids/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:378](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L378)

Road tile asset id.

# UnitPart

> **UnitPart** = [`ColoredUnitPart`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/coloredunitpart/) | [`NeutralUnitPart`](/declarative-hex-worlds/reference/scenario/catalog/type-aliases/neutralunitpart/)

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:372](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L372)

Any unit part id supported by catalog helpers.

# BASE_TILE_ASSET_IDS

> `const` **BASE\_TILE\_ASSET\_IDS**: readonly \[`"hex_grass_bottom"`, `"hex_grass_sloped_high"`, `"hex_grass_sloped_low"`, `"hex_grass"`, `"hex_water"`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:14](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L14)

Base and support tile asset ids used by terrain helpers.

# COAST_TILE_ASSET_IDS

> `const` **COAST\_TILE\_ASSET\_IDS**: readonly (`"hex_coast_A"` | `"hex_coast_A_waterless"` | `"hex_coast_B"` | `"hex_coast_B_waterless"` | `"hex_coast_C"` | `"hex_coast_C_waterless"` | `"hex_coast_D"` | `"hex_coast_D_waterless"` | `"hex_coast_E"` | `"hex_coast_E_waterless"`)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L45)

Coast and waterless coast tile asset ids from the guide index.

# COLORED_UNIT_PARTS

> `const` **COLORED\_UNIT\_PARTS**: readonly \[`"banner"`, `"bow"`, `"cannon"`, `"cart"`, `"cart_merchant"`, `"catapult"`, `"helmet"`, `"horse"`, `"projectile_arrow"`, `"shield"`, `"ship"`, `"spear"`, `"sword"`, `"unit"`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:304](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L304)

Faction-colored unit part ids expected from the local EXTRA ingest.

# EXTRA_FACTION_BUILDING_KINDS

> `const` **EXTRA\_FACTION\_BUILDING\_KINDS**: readonly \[`"docks"`, `"shipyard"`, `"shrine"`, `"stables"`, `"tent"`, `"townhall"`, `"tower_cannon"`, `"watchtower"`, `"workshop"`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:138](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L138)

Faction-colored building kinds expected from the local EXTRA ingest.

# EXTRA_PROP_ASSET_IDS

> `const` **EXTRA\_PROP\_ASSET\_IDS**: readonly \[`"anchor"`, `"boat"`, `"boatrack"`, `"cannonball_pallet"`, `"haybale"`, `"icon_combat"`, `"icon_range"`, `"trough"`, `"trough_long"`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:291](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L291)

Prop asset ids expected from the local EXTRA ingest.

# EXTRA_TRANSITION_TILE_ASSET_IDS

> `const` **EXTRA\_TRANSITION\_TILE\_ASSET\_IDS**: readonly \[`"hex_transition"`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:23](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L23)

EXTRA-only transition tile ids used for biome blends.

# EXTRA_UNIT_STYLES

> `const` **EXTRA\_UNIT\_STYLES**: readonly \[`"accent"`, `"full"`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:351](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L351)

Unit texture application styles available for colored unit parts.

# FACTION_BUILDING_KINDS

> `const` **FACTION\_BUILDING\_KINDS**: readonly \[`"archeryrange"`, `"barracks"`, `"blacksmith"`, `"castle"`, `"church"`, `"docks"`, `"home_A"`, `"home_B"`, `"lumbermill"`, `"market"`, `"mine"`, `"shipyard"`, `"shrine"`, `"stables"`, `"tavern"`, `"tent"`, `"townhall"`, `"tower_A"`, `"tower_B"`, `"tower_base"`, `"tower_cannon"`, `"tower_catapult"`, `"watchtower"`, `"watermill"`, `"well"`, `"windmill"`, `"workshop"`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:85](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L85)

All faction-colored building ids supported across FREE and EXTRA editions.

# FREE_FACTION_BUILDING_KINDS

> `const` **FREE\_FACTION\_BUILDING\_KINDS**: readonly \[`"archeryrange"`, `"barracks"`, `"blacksmith"`, `"castle"`, `"church"`, `"home_A"`, `"home_B"`, `"lumbermill"`, `"market"`, `"mine"`, `"tavern"`, `"tower_A"`, `"tower_B"`, `"tower_base"`, `"tower_catapult"`, `"watermill"`, `"well"`, `"windmill"`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:116](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L116)

Faction-colored building kinds available in the FREE KayKit pack.

# FREE_PROP_ASSET_IDS

> `const` **FREE\_PROP\_ASSET\_IDS**: readonly \[`"barrel"`, `"bucket_arrows"`, `"bucket_empty"`, `"bucket_water"`, `"crate_A_big"`, `"crate_A_small"`, `"crate_B_big"`, `"crate_B_small"`, `"crate_long_A"`, `"crate_long_B"`, `"crate_long_C"`, `"crate_long_empty"`, `"crate_open"`, `"flag_blue"`, `"flag_green"`, `"flag_red"`, `"flag_yellow"`, `"ladder"`, `"pallet"`, `"resource_lumber"`, `"resource_stone"`, `"sack"`, `"target"`, `"tent"`, `"weaponrack"`, `"wheelbarrow"`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:261](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L261)

Prop asset ids available in the FREE KayKit pack.

# NATURE_ASSET_IDS

> `const` **NATURE\_ASSET\_IDS**: readonly \[`"cloud_big"`, `"cloud_small"`, `"hill_single_A"`, `"hill_single_B"`, `"hill_single_C"`, `"hills_A"`, `"hills_A_trees"`, `"hills_B"`, `"hills_B_trees"`, `"hills_C"`, `"hills_C_trees"`, `"mountain_A"`, `"mountain_A_grass"`, `"mountain_A_grass_trees"`, `"mountain_B"`, `"mountain_B_grass"`, `"mountain_B_grass_trees"`, `"mountain_C"`, `"mountain_C_grass"`, `"mountain_C_grass_trees"`, `"rock_single_A"`, `"rock_single_B"`, `"rock_single_C"`, `"rock_single_D"`, `"rock_single_E"`, `"tree_single_A"`, `"tree_single_A_cut"`, `"tree_single_B"`, `"tree_single_B_cut"`, `"trees_A_cut"`, `"trees_A_large"`, `"trees_A_medium"`, `"trees_A_small"`, `"trees_B_cut"`, `"trees_B_large"`, `"trees_B_medium"`, `"trees_B_small"`, `"waterlily_A"`, `"waterlily_B"`, `"waterplant_A"`, `"waterplant_B"`, `"waterplant_C"`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:176](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L176)

Nature and terrain-detail asset ids available to placement helpers.

# NEUTRAL_STRUCTURE_KINDS

> `const` **NEUTRAL\_STRUCTURE\_KINDS**: readonly \[`"building_bridge_A"`, `"building_bridge_B"`, `"building_destroyed"`, `"building_dirt"`, `"building_grain"`, `"building_scaffolding"`, `"building_stage_A"`, `"building_stage_B"`, `"building_stage_C"`, `"fence_stone_straight"`, `"fence_stone_straight_gate"`, `"fence_wood_straight"`, `"fence_wood_straight_gate"`, `"projectile_catapult"`, `"wall_corner_A_gate"`, `"wall_corner_A_inside"`, `"wall_corner_A_outside"`, `"wall_corner_B_inside"`, `"wall_corner_B_outside"`, `"wall_straight"`, `"wall_straight_gate"`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:151](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L151)

Neutral structure asset ids available to placement helpers.

# NEUTRAL_UNIT_PARTS

> `const` **NEUTRAL\_UNIT\_PARTS**: readonly \[`"banner"`, `"bow"`, `"cannon"`, `"cart"`, `"cart_merchant"`, `"catapult"`, `"hammer"`, `"helmet"`, `"horse_A"`, `"horse_B"`, `"horse_C"`, `"horse_D"`, `"horse_E"`, `"horse_F"`, `"horse_G"`, `"horse_saddle"`, `"projectile_arrow"`, `"projectile_cannonball"`, `"projectile_catapult"`, `"shield"`, `"ship"`, `"shovel"`, `"spear"`, `"sword"`, `"unit"`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:322](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L322)

Neutral unit and equipment part ids expected from the local EXTRA ingest.

# PROP_ASSET_IDS

> `const` **PROP\_ASSET\_IDS**: readonly \[`"anchor"`, `"barrel"`, `"boat"`, `"boatrack"`, `"bucket_arrows"`, `"bucket_empty"`, `"bucket_water"`, `"cannonball_pallet"`, `"crate_A_big"`, `"crate_A_small"`, `"crate_B_big"`, `"crate_B_small"`, `"crate_long_A"`, `"crate_long_B"`, `"crate_long_C"`, `"crate_long_empty"`, `"crate_open"`, `"flag_blue"`, `"flag_green"`, `"flag_red"`, `"flag_yellow"`, `"haybale"`, `"icon_combat"`, `"icon_range"`, `"ladder"`, `"pallet"`, `"resource_lumber"`, `"resource_stone"`, `"sack"`, `"target"`, `"tent"`, `"trough"`, `"trough_long"`, `"weaponrack"`, `"wheelbarrow"`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:222](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L222)

All prop asset ids supported across FREE and EXTRA editions.

# RIVER_TILE_ASSET_IDS

> `const` **RIVER\_TILE\_ASSET\_IDS**: readonly \[`"hex_river_A_curvy"`, `"hex_river_A"`, `"hex_river_B"`, `"hex_river_C"`, `"hex_river_crossing_A"`, `"hex_river_crossing_B"`, `"hex_river_D"`, `"hex_river_E"`, `"hex_river_F"`, `"hex_river_G"`, `"hex_river_H"`, `"hex_river_I"`, `"hex_river_J"`, `"hex_river_K"`, `"hex_river_L"`, `"hex_river_A_curvy_waterless"`, `"hex_river_A_waterless"`, `"hex_river_B_waterless"`, `"hex_river_C_waterless"`, `"hex_river_crossing_A_waterless"`, `"hex_river_crossing_B_waterless"`, `"hex_river_D_waterless"`, `"hex_river_E_waterless"`, `"hex_river_F_waterless"`, `"hex_river_G_waterless"`, `"hex_river_H_waterless"`, `"hex_river_I_waterless"`, `"hex_river_J_waterless"`, `"hex_river_K_waterless"`, `"hex_river_L_waterless"`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:51](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L51)

River, curvy river, crossing, and waterless river asset ids from the guide.

# ROAD_TILE_ASSET_IDS

> `const` **ROAD\_TILE\_ASSET\_IDS**: readonly \[`"hex_road_A_sloped_high"`, `"hex_road_A_sloped_low"`, `"hex_road_A"`, `"hex_road_B"`, `"hex_road_C"`, `"hex_road_D"`, `"hex_road_E"`, `"hex_road_F"`, `"hex_road_G"`, `"hex_road_H"`, `"hex_road_I"`, `"hex_road_J"`, `"hex_road_K"`, `"hex_road_L"`, `"hex_road_M"`]

Defined in: [packages/declarative-hex-worlds/src/scenario/catalog.ts:26](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/catalog.ts#L26)

Road tile asset ids from the guide index.

# appendGameboardRecipeSteps

> **appendGameboardRecipeSteps**(`recipe`, `steps`): [`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:403](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L403)

Returns a new recipe with additional steps appended.

## Parameters

[Section titled “Parameters”](#parameters)

### recipe

[Section titled “recipe”](#recipe)

[`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

### steps

[Section titled “steps”](#steps)

readonly [`GameboardRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/type-aliases/gameboardrecipestep/)\[]

## Returns

[Section titled “Returns”](#returns)

[`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

# applyGameboardRecipe

> **applyGameboardRecipe**(`builder`, `recipeOrSteps`): [`GameboardBuilder`](/declarative-hex-worlds/reference/index/classes/gameboardbuilder/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:583](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L583)

Applies all recipe steps to an existing builder.

## Parameters

[Section titled “Parameters”](#parameters)

### builder

[Section titled “builder”](#builder)

[`GameboardBuilder`](/declarative-hex-worlds/reference/index/classes/gameboardbuilder/)

### recipeOrSteps

[Section titled “recipeOrSteps”](#recipeorsteps)

[`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/) | readonly [`GameboardRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/type-aliases/gameboardrecipestep/)\[]

## Returns

[Section titled “Returns”](#returns)

[`GameboardBuilder`](/declarative-hex-worlds/reference/index/classes/gameboardbuilder/)

# applyRecipeStep

> **applyRecipeStep**(`builder`, `step`): [`GameboardBuilder`](/declarative-hex-worlds/reference/index/classes/gameboardbuilder/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:595](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L595)

Applies one recipe step to an existing builder.

## Parameters

[Section titled “Parameters”](#parameters)

### builder

[Section titled “builder”](#builder)

[`GameboardBuilder`](/declarative-hex-worlds/reference/index/classes/gameboardbuilder/)

### step

[Section titled “step”](#step)

[`GameboardRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/type-aliases/gameboardrecipestep/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardBuilder`](/declarative-hex-worlds/reference/index/classes/gameboardbuilder/)

# createGameboardLayoutArchetypeRegistryFromRecipe

> **createGameboardLayoutArchetypeRegistryFromRecipe**(`recipe`): `Readonly`<`Record`<`string`, [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)>> | `undefined`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:728](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L728)

Creates the layout archetype registry declared by a recipe, when present.

## Parameters

[Section titled “Parameters”](#parameters)

### recipe

[Section titled “recipe”](#recipe)

[`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

## Returns

[Section titled “Returns”](#returns)

`Readonly`<`Record`<`string`, [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)>> | `undefined`

# createGameboardLayoutArchetypeRegistryFromRecipeGeneration

> **createGameboardLayoutArchetypeRegistryFromRecipeGeneration**(`generation`): `Readonly`<`Record`<`string`, [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)>> | `undefined`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:735](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L735)

Creates a layout archetype registry from recipe generation config.

## Parameters

[Section titled “Parameters”](#parameters)

### generation

[Section titled “generation”](#generation)

[`GameboardRecipeGeneration`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipegeneration/) | `undefined`

## Returns

[Section titled “Returns”](#returns)

`Readonly`<`Record`<`string`, [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)>> | `undefined`

# createGameboardPieceRegistryFromRecipe

> **createGameboardPieceRegistryFromRecipe**(`recipe`): [`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:721](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L721)

Creates the piece registry declared by a recipe, when any pieces are present.

## Parameters

[Section titled “Parameters”](#parameters)

### recipe

[Section titled “recipe”](#recipe)

[`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/) | `undefined`

# createGameboardPieceRegistryFromRecipeGeneration

> **createGameboardPieceRegistryFromRecipeGeneration**(`generation`): [`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:744](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L744)

Creates a piece registry from recipe generation config.

## Parameters

[Section titled “Parameters”](#parameters)

### generation

[Section titled “generation”](#generation)

[`GameboardRecipeGeneration`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipegeneration/) | `undefined`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPieceRegistry`](/declarative-hex-worlds/reference/index/interfaces/gameboardpieceregistry/) | `undefined`

# createGameboardPlanFromRecipe

> **createGameboardPlanFromRecipe**(`recipe`, `overrides?`, `applyGeneration?`): [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:488](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L488)

Compiles a recipe into a concrete gameboard plan.

## Parameters

[Section titled “Parameters”](#parameters)

### recipe

[Section titled “recipe”](#recipe)

[`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

### overrides?

[Section titled “overrides?”](#overrides)

[`GameboardRecipePlanOptionsOverride`](/declarative-hex-worlds/reference/scenario/recipe/type-aliases/gameboardrecipeplanoptionsoverride/) = `{}`

### applyGeneration?

[Section titled “applyGeneration?”](#applygeneration)

[`RecipeGenerationApplier`](/declarative-hex-worlds/reference/scenario/recipe/type-aliases/recipegenerationapplier/) = `...`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

# createGameboardRecipe

> **createGameboardRecipe**(`options`, `steps?`, `generation?`): [`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:389](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L389)

Creates a cloned, schema-tagged gameboard recipe.

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/)

### steps?

[Section titled “steps?”](#steps)

readonly [`GameboardRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/type-aliases/gameboardrecipestep/)\[] = `[]`

### generation?

[Section titled “generation?”](#generation)

[`GameboardRecipeGeneration`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipegeneration/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

# createGameboardRecipeGenerationFillRules

> **createGameboardRecipeGenerationFillRules**(`generation`): [`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:753](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L753)

Creates all layout fill rules implied by recipe generation config.

## Parameters

[Section titled “Parameters”](#parameters)

### generation

[Section titled “generation”](#generation)

[`GameboardRecipeGeneration`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipegeneration/) | `undefined`

## Returns

[Section titled “Returns”](#returns)

[`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

# inspectGameboardRecipe

> **inspectGameboardRecipe**(`recipe`, `config?`): [`GameboardRecipeValidationResult`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipevalidationresult/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:499](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L499)

Compiles and validates a recipe, returning errors instead of throwing.

## Parameters

[Section titled “Parameters”](#parameters)

### recipe

[Section titled “recipe”](#recipe)

[`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

### config?

[Section titled “config?”](#config)

[`GameboardRecipeValidationConfig`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipevalidationconfig/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardRecipeValidationResult`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipevalidationresult/)

# mergeGameboardRecipes

> **mergeGameboardRecipes**(`base`, `recipes`): [`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:416](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L416)

Merges explicit steps and generation config into one recipe.

## Parameters

[Section titled “Parameters”](#parameters)

### base

[Section titled “base”](#base)

[`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

### recipes

[Section titled “recipes”](#recipes)

readonly [`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)\[]

## Returns

[Section titled “Returns”](#returns)

[`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

# pureRecipeGenerationApplier

> **pureRecipeGenerationApplier**(`plan`, `generation`): [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:445](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L445)

The pure (koota-free) generation applier used by the `./core` tier. Seeded recipe generation requires a koota world to run layout-fill, which core does not depend on — so if a recipe declares generation fill rules, this throws a clear “use the runtime tier” error rather than silently dropping them. A generation block with no fill rules (or none at all) passes through unchanged.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### generation

[Section titled “generation”](#generation)

[`GameboardRecipeGeneration`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipegeneration/) | `undefined`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

# setDefaultRecipeGenerationApplier

> **setDefaultRecipeGenerationApplier**(`applier`): `void`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:477](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L477)

Set the process-wide default generation applier (the runtime tier wires koota). Pass `undefined` to clear it back to the pure default — mainly for tests that exercise the `./core`-tier (unregistered) code path.

## Parameters

[Section titled “Parameters”](#parameters)

### applier

[Section titled “applier”](#applier)

[`RecipeGenerationApplier`](/declarative-hex-worlds/reference/scenario/recipe/type-aliases/recipegenerationapplier/) | `undefined`

## Returns

[Section titled “Returns”](#returns)

`void`

# validateGameboardRecipe

> **validateGameboardRecipe**(`recipe`, `config?`): [`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:533](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L533)

Validates a recipe and returns all recipe/plan rule violations.

## Parameters

[Section titled “Parameters”](#parameters)

### recipe

[Section titled “recipe”](#recipe)

[`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

### config?

[Section titled “config?”](#config)

[`GameboardRecipeValidationConfig`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipevalidationconfig/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

# validateGameboardRecipeGeneration

> **validateGameboardRecipeGeneration**(`recipe`): [`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:541](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L541)

Validates generation-specific references before a recipe is compiled.

## Parameters

[Section titled “Parameters”](#parameters)

### recipe

[Section titled “recipe”](#recipe)

[`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

# AddBridgeRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:244](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L244)

Recipe step that places a bridge structure with bridge-specific metadata.

## Extends

[Section titled “Extends”](#extends)

* [`BridgeOptions`](/declarative-hex-worlds/reference/index/interfaces/bridgeoptions/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addBridge"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:246](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L246)

Discriminator for bridge placement.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:454](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L454)

Tile where the bridge is anchored, usually a road crossing over water or river terrain.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`BridgeOptions`](/declarative-hex-worlds/reference/index/interfaces/bridgeoptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/bridgeoptions/#at)

***

### facing?

[Section titled “facing?”](#facing)

> `optional` **facing?**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:458](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L458)

Edge the bridge points toward; also used as the default rotation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`BridgeOptions`](/declarative-hex-worlds/reference/index/interfaces/bridgeoptions/).[`facing`](/declarative-hex-worlds/reference/index/interfaces/bridgeoptions/#facing)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:460](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L460)

Clockwise 60-degree rotation steps. Overrides `facing` when provided.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`BridgeOptions`](/declarative-hex-worlds/reference/index/interfaces/bridgeoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/bridgeoptions/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:462](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L462)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`BridgeOptions`](/declarative-hex-worlds/reference/index/interfaces/bridgeoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/bridgeoptions/#scale)

***

### variant?

[Section titled “variant?”](#variant)

> `optional` **variant?**: [`BridgeVariant`](/declarative-hex-worlds/reference/index/type-aliases/bridgevariant/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:456](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L456)

KayKit bridge visual variant. Defaults to `A`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`BridgeOptions`](/declarative-hex-worlds/reference/index/interfaces/bridgeoptions/).[`variant`](/declarative-hex-worlds/reference/index/interfaces/bridgeoptions/#variant)

# AddConstructionSiteRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:256](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L256)

Recipe step that places a construction, ruin, or worksite structure.

## Extends

[Section titled “Extends”](#extends)

* [`ConstructionSiteOptions`](/declarative-hex-worlds/reference/index/interfaces/constructionsiteoptions/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addConstructionSite"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:258](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L258)

Discriminator for construction site placement.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:514](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L514)

Tile where the construction asset is anchored.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`ConstructionSiteOptions`](/declarative-hex-worlds/reference/index/interfaces/constructionsiteoptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/constructionsiteoptions/#at)

***

### constructionId?

[Section titled “constructionId?”](#constructionid)

> `optional` **constructionId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:520](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L520)

Optional stable id for a multi-step construction chain.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`ConstructionSiteOptions`](/declarative-hex-worlds/reference/index/interfaces/constructionsiteoptions/).[`constructionId`](/declarative-hex-worlds/reference/index/interfaces/constructionsiteoptions/#constructionid)

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`ConstructionSiteKind`](/declarative-hex-worlds/reference/index/type-aliases/constructionsitekind/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:516](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L516)

Construction state to place. Defaults to `stage-A`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`ConstructionSiteOptions`](/declarative-hex-worlds/reference/index/interfaces/constructionsiteoptions/).[`kind`](/declarative-hex-worlds/reference/index/interfaces/constructionsiteoptions/#kind)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:518](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L518)

Clockwise 60-degree rotation steps.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`ConstructionSiteOptions`](/declarative-hex-worlds/reference/index/interfaces/constructionsiteoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/constructionsiteoptions/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:522](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L522)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`ConstructionSiteOptions`](/declarative-hex-worlds/reference/index/interfaces/constructionsiteoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/constructionsiteoptions/#scale)

# AddElevationRampRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:268](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L268)

Recipe step that places a sloped elevation ramp with ramp-specific metadata.

## Extends

[Section titled “Extends”](#extends)

* [`ElevationRampOptions`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addElevationRamp"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:270](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L270)

Discriminator for elevation ramp placement.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:470](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L470)

Lower tile where the visible ramp is anchored.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`ElevationRampOptions`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/#at)

***

### direction?

[Section titled “direction?”](#direction)

> `optional` **direction?**: [`ElevationRampDirection`](/declarative-hex-worlds/reference/index/type-aliases/elevationrampdirection/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:472](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L472)

Visual ramp direction. Defaults to `up`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`ElevationRampOptions`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/).[`direction`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/#direction)

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:484](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L484)

Fractional elevation offset above the tile surface.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`ElevationRampOptions`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/).[`elevationOffset`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/#elevationoffset)

***

### facing?

[Section titled “facing?”](#facing)

> `optional` **facing?**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:474](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L474)

Edge the ramp points toward; also used as the default rotation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`ElevationRampOptions`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/).[`facing`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/#facing)

***

### fromElevation?

[Section titled “fromElevation?”](#fromelevation)

> `optional` **fromElevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:478](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L478)

Elevation on the anchor tile. Defaults to the tile elevation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`ElevationRampOptions`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/).[`fromElevation`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/#fromelevation)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:476](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L476)

Clockwise 60-degree rotation steps. Overrides `facing` when provided.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`ElevationRampOptions`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:486](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L486)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`ElevationRampOptions`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/#scale)

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:482](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L482)

Texture set to apply to the anchor tile before placing the ramp.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`ElevationRampOptions`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/).[`textureSet`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/#textureset)

***

### toElevation?

[Section titled “toElevation?”](#toelevation)

> `optional` **toElevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:480](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L480)

Elevation reached by the ramp. Defaults to one level above or below `fromElevation`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`ElevationRampOptions`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/).[`toElevation`](/declarative-hex-worlds/reference/index/interfaces/elevationrampoptions/#toelevation)

# AddFactionBuildingRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:232](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L232)

Recipe step that places a faction building.

## Extends

[Section titled “Extends”](#extends)

* [`FactionBuildingOptions`](/declarative-hex-worlds/reference/index/interfaces/factionbuildingoptions/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addFactionBuilding"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:234](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L234)

Discriminator for faction building placement.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:424](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L424)

Tile where the building is anchored.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`FactionBuildingOptions`](/declarative-hex-worlds/reference/index/interfaces/factionbuildingoptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/factionbuildingoptions/#at)

***

### building

[Section titled “building”](#building)

> **building**: `"archeryrange"` | `"barracks"` | `"blacksmith"` | `"castle"` | `"church"` | `"docks"` | `"home_A"` | `"home_B"` | `"lumbermill"` | `"market"` | `"mine"` | `"shipyard"` | `"shrine"` | `"stables"` | `"tavern"` | `"tent"` | `"townhall"` | `"tower_A"` | `"tower_B"` | `"tower_base"` | `"tower_cannon"` | `"tower_catapult"` | `"watchtower"` | `"watermill"` | `"well"` | `"windmill"` | `"workshop"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:428](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L428)

Faction building kind.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`FactionBuildingOptions`](/declarative-hex-worlds/reference/index/interfaces/factionbuildingoptions/).[`building`](/declarative-hex-worlds/reference/index/interfaces/factionbuildingoptions/#building)

***

### faction

[Section titled “faction”](#faction)

> **faction**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:426](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L426)

Faction color for the building.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`FactionBuildingOptions`](/declarative-hex-worlds/reference/index/interfaces/factionbuildingoptions/).[`faction`](/declarative-hex-worlds/reference/index/interfaces/factionbuildingoptions/#faction)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:430](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L430)

Clockwise 60-degree rotation steps.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`FactionBuildingOptions`](/declarative-hex-worlds/reference/index/interfaces/factionbuildingoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/factionbuildingoptions/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:432](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L432)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`FactionBuildingOptions`](/declarative-hex-worlds/reference/index/interfaces/factionbuildingoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/factionbuildingoptions/#scale)

# AddFlagRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:292](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L292)

Recipe step that places a faction flag.

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addFlag"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:294](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L294)

Discriminator for flag placement.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:296](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L296)

Target hex coordinate.

***

### faction

[Section titled “faction”](#faction)

> **faction**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:298](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L298)

Faction color/style to use for the flag.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:300](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L300)

Clockwise 60-degree rotation steps.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:302](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L302)

Optional placement scale override.

# AddForestRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:218](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L218)

Recipe step that places a KayKit forest feature.

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addForest"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:220](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L220)

Discriminator for forest placement.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:222](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L222)

Target hex coordinate.

***

### cut?

[Section titled “cut?”](#cut)

> `optional` **cut?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:228](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L228)

Whether to use a cut/logged forest variant.

***

### size?

[Section titled “size?”](#size)

> `optional` **size?**: `"small"` | `"medium"` | `"large"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:226](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L226)

Forest size variant.

***

### species?

[Section titled “species?”](#species)

> `optional` **species?**: `"A"` | `"B"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:224](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L224)

Tree species variant.

# AddFortificationRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:250](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L250)

Recipe step that places a wall or fence with fortification metadata.

## Extends

[Section titled “Extends”](#extends)

* [`FortificationOptions`](/declarative-hex-worlds/reference/index/interfaces/fortificationoptions/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addFortification"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:252](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L252)

Discriminator for fortification placement.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:494](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L494)

Tile where the segment is anchored.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`FortificationOptions`](/declarative-hex-worlds/reference/index/interfaces/fortificationoptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/fortificationoptions/#at)

***

### enclosureId?

[Section titled “enclosureId?”](#enclosureid)

> `optional` **enclosureId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:504](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L504)

Optional stable id for a multi-segment enclosure.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`FortificationOptions`](/declarative-hex-worlds/reference/index/interfaces/fortificationoptions/).[`enclosureId`](/declarative-hex-worlds/reference/index/interfaces/fortificationoptions/#enclosureid)

***

### facing?

[Section titled “facing?”](#facing)

> `optional` **facing?**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:500](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L500)

Edge the segment faces; also used as the default rotation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`FortificationOptions`](/declarative-hex-worlds/reference/index/interfaces/fortificationoptions/).[`facing`](/declarative-hex-worlds/reference/index/interfaces/fortificationoptions/#facing)

***

### material?

[Section titled “material?”](#material)

> `optional` **material?**: [`FortificationMaterial`](/declarative-hex-worlds/reference/index/type-aliases/fortificationmaterial/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:496](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L496)

Material family. Defaults to `wall`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`FortificationOptions`](/declarative-hex-worlds/reference/index/interfaces/fortificationoptions/).[`material`](/declarative-hex-worlds/reference/index/interfaces/fortificationoptions/#material)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:502](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L502)

Clockwise 60-degree rotation steps. Overrides `facing` when provided.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`FortificationOptions`](/declarative-hex-worlds/reference/index/interfaces/fortificationoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/fortificationoptions/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:506](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L506)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`FortificationOptions`](/declarative-hex-worlds/reference/index/interfaces/fortificationoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/fortificationoptions/#scale)

***

### segment?

[Section titled “segment?”](#segment)

> `optional` **segment?**: [`FortificationSegment`](/declarative-hex-worlds/reference/index/type-aliases/fortificationsegment/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:498](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L498)

Segment visual shape. Defaults to `straight`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`FortificationOptions`](/declarative-hex-worlds/reference/index/interfaces/fortificationoptions/).[`segment`](/declarative-hex-worlds/reference/index/interfaces/fortificationoptions/#segment)

# AddHarborRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:350](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L350)

Recipe step that places a harbor composition.

## Extends

[Section titled “Extends”](#extends)

* [`HarborOptions`](/declarative-hex-worlds/reference/index/interfaces/harboroptions/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addHarbor"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:352](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L352)

Discriminator for harbor placement.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:390](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L390)

Coast tile where the harbor is anchored.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`HarborOptions`](/declarative-hex-worlds/reference/index/interfaces/harboroptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/harboroptions/#at)

***

### facing

[Section titled “facing”](#facing)

> **facing**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:392](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L392)

Edge facing adjacent water.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`HarborOptions`](/declarative-hex-worlds/reference/index/interfaces/harboroptions/).[`facing`](/declarative-hex-worlds/reference/index/interfaces/harboroptions/#facing)

***

### faction

[Section titled “faction”](#faction)

> **faction**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:394](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L394)

Faction color for the harbor.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`HarborOptions`](/declarative-hex-worlds/reference/index/interfaces/harboroptions/).[`faction`](/declarative-hex-worlds/reference/index/interfaces/harboroptions/#faction)

***

### includeProps?

[Section titled “includeProps?”](#includeprops)

> `optional` **includeProps?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:398](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L398)

Whether to add adjacent boat/anchor props.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`HarborOptions`](/declarative-hex-worlds/reference/index/interfaces/harboroptions/).[`includeProps`](/declarative-hex-worlds/reference/index/interfaces/harboroptions/#includeprops)

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`HarborKind`](/declarative-hex-worlds/reference/index/type-aliases/harborkind/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:396](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L396)

Harbor structure variant.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`HarborOptions`](/declarative-hex-worlds/reference/index/interfaces/harboroptions/).[`kind`](/declarative-hex-worlds/reference/index/interfaces/harboroptions/#kind)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:400](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L400)

Clockwise 60-degree rotation steps. Defaults to `facing`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`HarborOptions`](/declarative-hex-worlds/reference/index/interfaces/harboroptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/harboroptions/#rotationsteps)

# AddHillRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:202](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L202)

Recipe step that places a hill tile.

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addHill"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:204](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L204)

Discriminator for hill placement.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:206](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L206)

Target hex coordinate.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:214](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L214)

Clockwise 60-degree rotation steps.

***

### single?

[Section titled “single?”](#single)

> `optional` **single?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:212](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L212)

Whether to use the single-hex hill style.

***

### variant?

[Section titled “variant?”](#variant)

> `optional` **variant?**: [`HillVariant`](/declarative-hex-worlds/reference/index/type-aliases/hillvariant/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:208](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L208)

KayKit hill variant to place.

***

### withTrees?

[Section titled “withTrees?”](#withtrees)

> `optional` **withTrees?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:210](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L210)

Whether to use a hill asset with trees.

# AddMountainStackRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:196](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L196)

Recipe step that places a composed mountain stack.

## Extends

[Section titled “Extends”](#extends)

* [`MountainStackOptions`](/declarative-hex-worlds/reference/index/interfaces/mountainstackoptions/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addMountainStack"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:198](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L198)

Discriminator for mountain stack placement.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:370](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L370)

Tile where the mountain stack is anchored.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`MountainStackOptions`](/declarative-hex-worlds/reference/index/interfaces/mountainstackoptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/mountainstackoptions/#at)

***

### height

[Section titled “height”](#height)

> **height**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:372](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L372)

Elevation height for the stack.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`MountainStackOptions`](/declarative-hex-worlds/reference/index/interfaces/mountainstackoptions/).[`height`](/declarative-hex-worlds/reference/index/interfaces/mountainstackoptions/#height)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:380](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L380)

Clockwise 60-degree rotation steps.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`MountainStackOptions`](/declarative-hex-worlds/reference/index/interfaces/mountainstackoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/mountainstackoptions/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:382](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L382)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`MountainStackOptions`](/declarative-hex-worlds/reference/index/interfaces/mountainstackoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/mountainstackoptions/#scale)

***

### variant?

[Section titled “variant?”](#variant)

> `optional` **variant?**: [`MountainVariant`](/declarative-hex-worlds/reference/index/type-aliases/mountainvariant/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:374](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L374)

Mountain visual variant.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`MountainStackOptions`](/declarative-hex-worlds/reference/index/interfaces/mountainstackoptions/).[`variant`](/declarative-hex-worlds/reference/index/interfaces/mountainstackoptions/#variant)

***

### withGrass?

[Section titled “withGrass?”](#withgrass)

> `optional` **withGrass?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:376](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L376)

Include grass on the mountain asset.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`MountainStackOptions`](/declarative-hex-worlds/reference/index/interfaces/mountainstackoptions/).[`withGrass`](/declarative-hex-worlds/reference/index/interfaces/mountainstackoptions/#withgrass)

***

### withTrees?

[Section titled “withTrees?”](#withtrees)

> `optional` **withTrees?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:378](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L378)

Include trees on the mountain asset.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`MountainStackOptions`](/declarative-hex-worlds/reference/index/interfaces/mountainstackoptions/).[`withTrees`](/declarative-hex-worlds/reference/index/interfaces/mountainstackoptions/#withtrees)

# AddNatureRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:274](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L274)

Recipe step that places a nature asset.

## Extends

[Section titled “Extends”](#extends)

* [`NaturePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/natureplacementoptions/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addNature"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:276](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L276)

Discriminator for nature placement.

***

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `"cloud_big"` | `"cloud_small"` | `"hill_single_A"` | `"hill_single_B"` | `"hill_single_C"` | `"hills_A"` | `"hills_A_trees"` | `"hills_B"` | `"hills_B_trees"` | `"hills_C"` | `"hills_C_trees"` | `"mountain_A"` | `"mountain_A_grass"` | `"mountain_A_grass_trees"` | `"mountain_B"` | `"mountain_B_grass"` | `"mountain_B_grass_trees"` | `"mountain_C"` | `"mountain_C_grass"` | `"mountain_C_grass_trees"` | `"rock_single_A"` | `"rock_single_B"` | `"rock_single_C"` | `"rock_single_D"` | `"rock_single_E"` | `"tree_single_A"` | `"tree_single_A_cut"` | `"tree_single_B"` | `"tree_single_B_cut"` | `"trees_A_cut"` | `"trees_A_large"` | `"trees_A_medium"` | `"trees_A_small"` | `"trees_B_cut"` | `"trees_B_large"` | `"trees_B_medium"` | `"trees_B_small"` | `"waterlily_A"` | `"waterlily_B"` | `"waterplant_A"` | `"waterplant_B"` | `"waterplant_C"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:550](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L550)

Nature asset id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`NaturePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/natureplacementoptions/).[`assetId`](/declarative-hex-worlds/reference/index/interfaces/natureplacementoptions/#assetid)

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:548](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L548)

Tile where the nature asset is anchored.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`NaturePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/natureplacementoptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/natureplacementoptions/#at)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:552](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L552)

Clockwise 60-degree rotation steps.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`NaturePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/natureplacementoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/natureplacementoptions/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:554](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L554)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`NaturePlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/natureplacementoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/natureplacementoptions/#scale)

# AddNeutralStructureRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:238](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L238)

Recipe step that places a neutral structure.

## Extends

[Section titled “Extends”](#extends)

* [`NeutralStructureOptions`](/declarative-hex-worlds/reference/index/interfaces/neutralstructureoptions/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addNeutralStructure"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:240](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L240)

Discriminator for neutral structure placement.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:440](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L440)

Tile where the structure is anchored.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`NeutralStructureOptions`](/declarative-hex-worlds/reference/index/interfaces/neutralstructureoptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/neutralstructureoptions/#at)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:444](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L444)

Clockwise 60-degree rotation steps.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`NeutralStructureOptions`](/declarative-hex-worlds/reference/index/interfaces/neutralstructureoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/neutralstructureoptions/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:446](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L446)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`NeutralStructureOptions`](/declarative-hex-worlds/reference/index/interfaces/neutralstructureoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/neutralstructureoptions/#scale)

***

### structure

[Section titled “structure”](#structure)

> **structure**: `"projectile_catapult"` | `"building_bridge_A"` | `"building_bridge_B"` | `"building_destroyed"` | `"building_dirt"` | `"building_grain"` | `"building_scaffolding"` | `"building_stage_A"` | `"building_stage_B"` | `"building_stage_C"` | `"fence_stone_straight"` | `"fence_stone_straight_gate"` | `"fence_wood_straight"` | `"fence_wood_straight_gate"` | `"wall_corner_A_gate"` | `"wall_corner_A_inside"` | `"wall_corner_A_outside"` | `"wall_corner_B_inside"` | `"wall_corner_B_outside"` | `"wall_straight"` | `"wall_straight_gate"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:442](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L442)

Neutral structure asset id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`NeutralStructureOptions`](/declarative-hex-worlds/reference/index/interfaces/neutralstructureoptions/).[`structure`](/declarative-hex-worlds/reference/index/interfaces/neutralstructureoptions/#structure)

# AddPlacementRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:306](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L306)

Recipe step that places an arbitrary asset with explicit placement semantics.

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addPlacement"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:308](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L308)

Discriminator for custom placement creation.

***

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:312](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L312)

Asset id to place.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:310](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L310)

Target hex coordinate.

***

### elevationOffset?

[Section titled “elevationOffset?”](#elevationoffset)

> `optional` **elevationOffset?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:320](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L320)

Fractional elevation offset above the tile surface.

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:314](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L314)

Gameplay/render category for the placement.

***

### layer

[Section titled “layer”](#layer)

> **layer**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:316](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L316)

Render and gameplay layer for the placement.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:328](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L328)

Serializable placement metadata.

***

### requiresExtra?

[Section titled “requiresExtra?”](#requiresextra)

> `optional` **requiresExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:326](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L326)

Whether the placement requires local EXTRA assets.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:318](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L318)

Clockwise 60-degree rotation steps.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:322](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L322)

Uniform render scale.

***

### stackIndex?

[Section titled “stackIndex?”](#stackindex)

> `optional` **stackIndex?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:324](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L324)

Optional stack order metadata.

# AddPropClusterRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:286](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L286)

Recipe step that places a semantic prop cluster.

## Extends

[Section titled “Extends”](#extends)

* [`PropClusterOptions`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addPropCluster"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:288](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L288)

Discriminator for prop-cluster placement.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:576](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L576)

Anchor tile for the cluster.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`PropClusterOptions`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/#at)

***

### clusterId?

[Section titled “clusterId?”](#clusterid)

> `optional` **clusterId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:588](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L588)

Optional stable id shared by all placements in the cluster.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`PropClusterOptions`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/).[`clusterId`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/#clusterid)

***

### density?

[Section titled “density?”](#density)

> `optional` **density?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:584](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L584)

Percentage of the cluster’s available asset list to place, from 0 to 1. Defaults to 1.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`PropClusterOptions`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/).[`density`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/#density)

***

### facing?

[Section titled “facing?”](#facing)

> `optional` **facing?**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:580](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L580)

Edge used to orient adjacent spread patterns.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`PropClusterOptions`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/).[`facing`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/#facing)

***

### includeExtra?

[Section titled “includeExtra?”](#includeextra)

> `optional` **includeExtra?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:586](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L586)

Include local-only EXTRA prop assets when the cluster kind has them. Defaults to false.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`PropClusterOptions`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/).[`includeExtra`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/#includeextra)

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`PropClusterKind`](/declarative-hex-worlds/reference/index/type-aliases/propclusterkind/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:578](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L578)

Cluster purpose. Determines the default asset list.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`PropClusterOptions`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/).[`kind`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/#kind)

***

### placement?

[Section titled “placement?”](#placement)

> `optional` **placement?**: [`PropClusterPlacement`](/declarative-hex-worlds/reference/index/type-aliases/propclusterplacement/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:582](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L582)

Whether assets stack on one tile or spread to neighboring tiles. Defaults to `adjacent`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`PropClusterOptions`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/).[`placement`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/#placement)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:590](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L590)

Base clockwise 60-degree rotation steps. Defaults to `facing`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`PropClusterOptions`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:592](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L592)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`PropClusterOptions`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/propclusteroptions/#scale)

# AddPropRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:280](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L280)

Recipe step that places a prop asset.

## Extends

[Section titled “Extends”](#extends)

* [`PropPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/propplacementoptions/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addProp"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:282](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L282)

Discriminator for prop placement.

***

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `"tent"` | `"anchor"` | `"barrel"` | `"boat"` | `"boatrack"` | `"bucket_arrows"` | `"bucket_empty"` | `"bucket_water"` | `"cannonball_pallet"` | `"crate_A_big"` | `"crate_A_small"` | `"crate_B_big"` | `"crate_B_small"` | `"crate_long_A"` | `"crate_long_B"` | `"crate_long_C"` | `"crate_long_empty"` | `"crate_open"` | `"flag_blue"` | `"flag_green"` | `"flag_red"` | `"flag_yellow"` | `"haybale"` | `"icon_combat"` | `"icon_range"` | `"ladder"` | `"pallet"` | `"resource_lumber"` | `"resource_stone"` | `"sack"` | `"target"` | `"trough"` | `"trough_long"` | `"weaponrack"` | `"wheelbarrow"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:564](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L564)

Prop asset id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`PropPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/propplacementoptions/).[`assetId`](/declarative-hex-worlds/reference/index/interfaces/propplacementoptions/#assetid)

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:562](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L562)

Tile where the prop is anchored.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`PropPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/propplacementoptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/propplacementoptions/#at)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:566](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L566)

Clockwise 60-degree rotation steps.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`PropPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/propplacementoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/propplacementoptions/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:568](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L568)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`PropPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/propplacementoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/propplacementoptions/#scale)

# AddRiverPathRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:182](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L182)

Recipe step that lays river surfaces along a coordinate path.

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addRiverPath"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:184](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L184)

Discriminator for river path creation.

***

### crossing?

[Section titled “crossing?”](#crossing)

> `optional` **crossing?**: [`RiverCrossing`](/declarative-hex-worlds/reference/index/type-aliases/rivercrossing/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:192](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L192)

Crossing variant to place where road/river crossings are desired.

***

### curvy?

[Section titled “curvy?”](#curvy)

> `optional` **curvy?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:190](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L190)

Whether to prefer curvy river variants.

***

### path

[Section titled “path”](#path)

> **path**: readonly [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:186](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L186)

Ordered coordinates along the river.

***

### waterless?

[Section titled “waterless?”](#waterless)

> `optional` **waterless?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:188](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L188)

Whether to use waterless river banks.

# AddRoadPathRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:172](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L172)

Recipe step that lays road surfaces along a coordinate path.

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addRoadPath"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:174](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L174)

Discriminator for road path creation.

***

### path

[Section titled “path”](#path)

> **path**: readonly [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:176](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L176)

Ordered coordinates along the road.

***

### slope?

[Section titled “slope?”](#slope)

> `optional` **slope?**: [`RoadSlope`](/declarative-hex-worlds/reference/index/type-aliases/roadslope/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:178](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L178)

Optional road slope variant for the path.

# AddSiegeProjectileRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:262](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L262)

Recipe step that places a neutral siege projectile.

## Extends

[Section titled “Extends”](#extends)

* [`SiegeProjectileOptions`](/declarative-hex-worlds/reference/index/interfaces/siegeprojectileoptions/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addSiegeProjectile"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:264](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L264)

Discriminator for siege projectile placement.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:530](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L530)

Tile where the projectile is anchored.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`SiegeProjectileOptions`](/declarative-hex-worlds/reference/index/interfaces/siegeprojectileoptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/siegeprojectileoptions/#at)

***

### facing?

[Section titled “facing?”](#facing)

> `optional` **facing?**: [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:534](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L534)

Edge the projectile travels or points toward; also used as the default rotation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`SiegeProjectileOptions`](/declarative-hex-worlds/reference/index/interfaces/siegeprojectileoptions/).[`facing`](/declarative-hex-worlds/reference/index/interfaces/siegeprojectileoptions/#facing)

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: `"catapult"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:532](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L532)

Projectile visual kind. Defaults to `catapult`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`SiegeProjectileOptions`](/declarative-hex-worlds/reference/index/interfaces/siegeprojectileoptions/).[`kind`](/declarative-hex-worlds/reference/index/interfaces/siegeprojectileoptions/#kind)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:536](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L536)

Clockwise 60-degree rotation steps. Overrides `facing` when provided.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`SiegeProjectileOptions`](/declarative-hex-worlds/reference/index/interfaces/siegeprojectileoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/siegeprojectileoptions/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:540](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L540)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`SiegeProjectileOptions`](/declarative-hex-worlds/reference/index/interfaces/siegeprojectileoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/siegeprojectileoptions/#scale)

***

### sourceId?

[Section titled “sourceId?”](#sourceid)

> `optional` **sourceId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:538](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L538)

Optional source actor, structure, or attack id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`SiegeProjectileOptions`](/declarative-hex-worlds/reference/index/interfaces/siegeprojectileoptions/).[`sourceId`](/declarative-hex-worlds/reference/index/interfaces/siegeprojectileoptions/#sourceid)

# AddTransitionRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:332](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L332)

Recipe step that places an EXTRA transition asset.

## Extends

[Section titled “Extends”](#extends)

* [`TransitionPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/transitionplacementoptions/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addTransition"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:334](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L334)

Discriminator for transition placement.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:600](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L600)

Tile where the transition is anchored.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`TransitionPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/transitionplacementoptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/transitionplacementoptions/#at)

***

### from

[Section titled “from”](#from)

> **from**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:602](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L602)

Source texture set.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`TransitionPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/transitionplacementoptions/).[`from`](/declarative-hex-worlds/reference/index/interfaces/transitionplacementoptions/#from)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:606](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L606)

Clockwise 60-degree rotation steps.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`TransitionPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/transitionplacementoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/transitionplacementoptions/#rotationsteps)

***

### to

[Section titled “to”](#to)

> **to**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:604](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L604)

Destination texture set.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`TransitionPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/transitionplacementoptions/).[`to`](/declarative-hex-worlds/reference/index/interfaces/transitionplacementoptions/#to)

# AddUnitPresetRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:344](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L344)

Recipe step that places a unit preset composition.

## Extends

[Section titled “Extends”](#extends)

* [`UnitPresetOptions`](/declarative-hex-worlds/reference/index/interfaces/unitpresetoptions/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addUnitPreset"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:346](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L346)

Discriminator for unit preset placement.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:636](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L636)

Tile where the unit preset is anchored.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`UnitPresetOptions`](/declarative-hex-worlds/reference/index/interfaces/unitpresetoptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/unitpresetoptions/#at)

***

### faction

[Section titled “faction”](#faction)

> **faction**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:638](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L638)

Faction used by colored unit parts.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`UnitPresetOptions`](/declarative-hex-worlds/reference/index/interfaces/unitpresetoptions/).[`faction`](/declarative-hex-worlds/reference/index/interfaces/unitpresetoptions/#faction)

***

### role

[Section titled “role”](#role)

> **role**: `"ship"` | `"worker"` | `"soldier"` | `"archer"` | `"cavalry"` | `"merchant"` | `"siege"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:642](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L642)

Unit role composition to create.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`UnitPresetOptions`](/declarative-hex-worlds/reference/index/interfaces/unitpresetoptions/).[`role`](/declarative-hex-worlds/reference/index/interfaces/unitpresetoptions/#role)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:644](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L644)

Clockwise 60-degree rotation steps.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`UnitPresetOptions`](/declarative-hex-worlds/reference/index/interfaces/unitpresetoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/unitpresetoptions/#rotationsteps)

***

### style?

[Section titled “style?”](#style)

> `optional` **style?**: `"accent"` | `"full"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:640](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L640)

Colored unit style.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`UnitPresetOptions`](/declarative-hex-worlds/reference/index/interfaces/unitpresetoptions/).[`style`](/declarative-hex-worlds/reference/index/interfaces/unitpresetoptions/#style)

# AddUnitRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:338](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L338)

Recipe step that places a single unit asset.

## Extends

[Section titled “Extends”](#extends)

* [`UnitPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"addUnit"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:340](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L340)

Discriminator for unit placement.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:614](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L614)

Tile where the unit part is anchored.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`UnitPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/#at)

***

### compositeId?

[Section titled “compositeId?”](#compositeid)

> `optional` **compositeId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:624](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L624)

Shared composite id for multi-part units.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`UnitPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/).[`compositeId`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/#compositeid)

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:618](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L618)

Faction used by colored unit parts.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`UnitPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/).[`faction`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/#faction)

***

### neutral?

[Section titled “neutral?”](#neutral)

> `optional` **neutral?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:622](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L622)

Force neutral unit asset selection.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`UnitPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/).[`neutral`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/#neutral)

***

### part

[Section titled “part”](#part)

> **part**: `"banner"` | `"bow"` | `"cannon"` | `"cart"` | `"cart_merchant"` | `"catapult"` | `"helmet"` | `"horse"` | `"projectile_arrow"` | `"shield"` | `"ship"` | `"spear"` | `"sword"` | `"unit"` | `"hammer"` | `"horse_A"` | `"horse_B"` | `"horse_C"` | `"horse_D"` | `"horse_E"` | `"horse_F"` | `"horse_G"` | `"horse_saddle"` | `"projectile_cannonball"` | `"projectile_catapult"` | `"shovel"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:616](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L616)

Unit part asset id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`UnitPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/).[`part`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/#part)

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:626](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L626)

Clockwise 60-degree rotation steps.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`UnitPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/).[`rotationSteps`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/#rotationsteps)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:628](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L628)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`UnitPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/#scale)

***

### style?

[Section titled “style?”](#style)

> `optional` **style?**: `"accent"` | `"full"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:620](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L620)

Colored unit style.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`UnitPlacementOptions`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/).[`style`](/declarative-hex-worlds/reference/index/interfaces/unitplacementoptions/#style)

# GameboardRecipe

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:62](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L62)

Serializable recipe for constructing and optionally generating a gameboard plan.

## Properties

[Section titled “Properties”](#properties)

### generation?

[Section titled “generation?”](#generation)

> `optional` **generation?**: [`GameboardRecipeGeneration`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipegeneration/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:70](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L70)

Optional seeded generation configuration applied after explicit steps.

***

### options

[Section titled “options”](#options)

> **options**: [`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:66](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L66)

Base plan options used before step and generation application.

***

### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> **schemaVersion**: `"1.0.0"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:64](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L64)

Version tag for migration-safe recipe persistence.

***

### steps

[Section titled “steps”](#steps)

> **steps**: readonly [`GameboardRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/type-aliases/gameboardrecipestep/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:68](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L68)

Ordered imperative builder steps.

# GameboardRecipeGeneration

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:74](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L74)

Seeded generation configuration embedded in a recipe.

## Properties

[Section titled “Properties”](#properties)

### layoutArchetypes?

[Section titled “layoutArchetypes?”](#layoutarchetypes)

> `optional` **layoutArchetypes?**: `Readonly`<`Record`<`string`, [`GameboardLayoutArchetype`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutarchetype/)>>

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:76](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L76)

Layout archetypes available to layout and piece fill rules.

***

### layoutFills?

[Section titled “layoutFills?”](#layoutfills)

> `optional` **layoutFills?**: readonly [`GameboardLayoutFillRule`](/declarative-hex-worlds/reference/coordinates/layout/interfaces/gameboardlayoutfillrule/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:80](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L80)

Rules that spawn placements directly from layout archetypes.

***

### layoutFillSeed?

[Section titled “layoutFillSeed?”](#layoutfillseed)

> `optional` **layoutFillSeed?**: `string` | `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:78](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L78)

Seed used by layout fill spawning.

***

### pieceDeclarations?

[Section titled “pieceDeclarations?”](#piecedeclarations)

> `optional` **pieceDeclarations?**: readonly [`GameboardPieceDeclarationInput`](/declarative-hex-worlds/reference/index/interfaces/gameboardpiecedeclarationinput/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:82](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L82)

Piece declarations used by seeded piece fill rules.

***

### pieceFills?

[Section titled “pieceFills?”](#piecefills)

> `optional` **pieceFills?**: readonly [`SeededGameboardPieceFillOptions`](/declarative-hex-worlds/reference/index/interfaces/seededgameboardpiecefilloptions/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:84](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L84)

Rules that spawn registered pieces from seeded percentage fills.

# GameboardRecipeValidationConfig

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:365](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L365)

Validation options for recipe preflight and compiled plan checks.

## Properties

[Section titled “Properties”](#properties)

### overrides?

[Section titled “overrides?”](#overrides)

> `optional` **overrides?**: `Partial`<[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/)>

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:367](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L367)

Plan option overrides applied before validating the compiled plan.

***

### plan?

[Section titled “plan?”](#plan)

> `optional` **plan?**: [`GameboardPlanValidationConfig`](/declarative-hex-worlds/reference/rules/validation/interfaces/gameboardplanvalidationconfig/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:369](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L369)

Validation config passed through to plan validation.

# GameboardRecipeValidationResult

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:373](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L373)

Result from compiling and validating a recipe.

## Properties

[Section titled “Properties”](#properties)

### plan?

[Section titled “plan?”](#plan)

> `optional` **plan?**: [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:377](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L377)

Compiled plan when compilation succeeds.

***

### recipe

[Section titled “recipe”](#recipe)

> **recipe**: [`GameboardRecipe`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipe/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:375](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L375)

Recipe that was inspected.

***

### violations

[Section titled “violations”](#violations)

> **violations**: readonly [`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:379](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L379)

Preflight and compiled-plan validation violations.

# ScatterDecorationsRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:356](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L356)

Recipe step that scatters decoration assets across matching tiles.

## Extends

[Section titled “Extends”](#extends)

* [`ScatterDecorationOptions`](/declarative-hex-worlds/reference/index/interfaces/scatterdecorationoptions/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"scatterDecorations"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:358](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L358)

Discriminator for decoration scatter placement.

***

### assets

[Section titled “assets”](#assets)

> **assets**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:690](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L690)

Candidate asset ids for each decoration.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`ScatterDecorationOptions`](/declarative-hex-worlds/reference/index/interfaces/scatterdecorationoptions/).[`assets`](/declarative-hex-worlds/reference/index/interfaces/scatterdecorationoptions/#assets)

***

### avoidOccupied?

[Section titled “avoidOccupied?”](#avoidoccupied)

> `optional` **avoidOccupied?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:694](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L694)

Avoid tiles with existing custom placements.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`ScatterDecorationOptions`](/declarative-hex-worlds/reference/index/interfaces/scatterdecorationoptions/).[`avoidOccupied`](/declarative-hex-worlds/reference/index/interfaces/scatterdecorationoptions/#avoidoccupied)

***

### count

[Section titled “count”](#count)

> **count**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:688](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L688)

Number of decorations to place.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`ScatterDecorationOptions`](/declarative-hex-worlds/reference/index/interfaces/scatterdecorationoptions/).[`count`](/declarative-hex-worlds/reference/index/interfaces/scatterdecorationoptions/#count)

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:696](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L696)

Uniform render scale.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`ScatterDecorationOptions`](/declarative-hex-worlds/reference/index/interfaces/scatterdecorationoptions/).[`scale`](/declarative-hex-worlds/reference/index/interfaces/scatterdecorationoptions/#scale)

***

### terrain?

[Section titled “terrain?”](#terrain)

> `optional` **terrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/) | readonly [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:692](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L692)

Allowed terrain for decoration sites.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`ScatterDecorationOptions`](/declarative-hex-worlds/reference/index/interfaces/scatterdecorationoptions/).[`terrain`](/declarative-hex-worlds/reference/index/interfaces/scatterdecorationoptions/#terrain)

# SetCoastEdgesRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:160](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L160)

Recipe step that records coastal water edge connectivity for one hex.

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"setCoastEdges"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:162](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L162)

Discriminator for coastal edge assignment.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:164](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L164)

Target hex coordinate.

***

### waterEdges

[Section titled “waterEdges”](#wateredges)

> **waterEdges**: `number` | readonly [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:166](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L166)

Water-facing edges as indexes or a canonical bit mask.

***

### waterless?

[Section titled “waterless?”](#waterless)

> `optional` **waterless?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:168](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L168)

Whether to choose the waterless coast variant.

# SetElevationRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:140](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L140)

Recipe step that changes one hex elevation.

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"setElevation"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:142](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L142)

Discriminator for elevation assignment.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:144](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L144)

Target hex coordinate.

***

### elevation

[Section titled “elevation”](#elevation)

> **elevation**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:146](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L146)

Elevation level to assign.

# SetTerrainRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:118](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L118)

Recipe step that assigns grass or water terrain to one hex.

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"setTerrain"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:120](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L120)

Discriminator for terrain assignment.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:122](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L122)

Target hex coordinate.

***

### baseAssetId?

[Section titled “baseAssetId?”](#baseassetid)

> `optional` **baseAssetId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L128)

Optional base tile asset override for the terrain.

***

### elevation?

[Section titled “elevation?”](#elevation)

> `optional` **elevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L126)

Optional elevation to assign with the terrain.

***

### terrain

[Section titled “terrain”](#terrain)

> **terrain**: `"grass"` | `"water"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:124](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L124)

Terrain value to assign.

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L130)

Optional texture set override for this tile.

# SetTextureSetRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:150](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L150)

Recipe step that changes one hex texture set without changing terrain.

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"setTextureSet"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:152](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L152)

Discriminator for texture-set assignment.

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:154](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L154)

Target hex coordinate.

***

### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:156](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L156)

KayKit texture set to apply to the tile.

# SetTileAssetRecipeStep

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L134)

Recipe step that applies a fully specified tile asset option object.

## Extends

[Section titled “Extends”](#extends)

* [`TileAssetOptions`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/)

## Properties

[Section titled “Properties”](#properties)

### action

[Section titled “action”](#action)

> **action**: `"setTileAsset"`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L136)

Discriminator for direct tile asset assignment.

***

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:654](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L654)

Base tile asset id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`TileAssetOptions`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/).[`assetId`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/#assetid)

***

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:652](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L652)

Tile whose asset state should be replaced.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`TileAssetOptions`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/).[`at`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/#at)

***

### coastEdges?

[Section titled “coastEdges?”](#coastedges)

> `optional` **coastEdges?**: [`HexEdgeInput`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeinput/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:666](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L666)

Replacement coast edge input.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`TileAssetOptions`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/).[`coastEdges`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/#coastedges)

***

### coastWaterless?

[Section titled “coastWaterless?”](#coastwaterless)

> `optional` **coastWaterless?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:676](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L676)

Whether the coast uses a waterless variant.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`TileAssetOptions`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/).[`coastWaterless`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/#coastwaterless)

***

### elevation?

[Section titled “elevation?”](#elevation)

> `optional` **elevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:660](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L660)

Replacement elevation.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`TileAssetOptions`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/).[`elevation`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/#elevation)

***

### riverCrossing?

[Section titled “riverCrossing?”](#rivercrossing)

> `optional` **riverCrossing?**: [`RiverCrossing`](/declarative-hex-worlds/reference/index/type-aliases/rivercrossing/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:674](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L674)

River crossing variant.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`TileAssetOptions`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/).[`riverCrossing`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/#rivercrossing)

***

### riverCurvy?

[Section titled “riverCurvy?”](#rivercurvy)

> `optional` **riverCurvy?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:672](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L672)

Whether the river uses a curvy variant.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`TileAssetOptions`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/).[`riverCurvy`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/#rivercurvy)

***

### riverEdges?

[Section titled “riverEdges?”](#riveredges)

> `optional` **riverEdges?**: [`HexEdgeInput`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeinput/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:664](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L664)

Replacement river edge input.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`TileAssetOptions`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/).[`riverEdges`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/#riveredges)

***

### riverWaterless?

[Section titled “riverWaterless?”](#riverwaterless)

> `optional` **riverWaterless?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:670](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L670)

Whether the river uses a waterless variant.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`TileAssetOptions`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/).[`riverWaterless`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/#riverwaterless)

***

### roadEdges?

[Section titled “roadEdges?”](#roadedges)

> `optional` **roadEdges?**: [`HexEdgeInput`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeinput/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:662](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L662)

Replacement road edge input.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`TileAssetOptions`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/).[`roadEdges`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/#roadedges)

***

### roadSlope?

[Section titled “roadSlope?”](#roadslope)

> `optional` **roadSlope?**: [`RoadSlope`](/declarative-hex-worlds/reference/index/type-aliases/roadslope/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:668](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L668)

Road slope variant.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`TileAssetOptions`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/).[`roadSlope`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/#roadslope)

***

### supportAssetId?

[Section titled “supportAssetId?”](#supportassetid)

> `optional` **supportAssetId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:658](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L658)

Replacement support/bottom asset id.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`TileAssetOptions`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/).[`supportAssetId`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/#supportassetid)

***

### tags?

[Section titled “tags?”](#tags)

> `optional` **tags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:680](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L680)

Additional tile tags.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

[`TileAssetOptions`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/).[`tags`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/#tags)

***

### terrain?

[Section titled “terrain?”](#terrain)

> `optional` **terrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:656](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L656)

Replacement terrain category.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`TileAssetOptions`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/).[`terrain`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/#terrain)

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/gameboard/plan.ts:678](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/gameboard/plan.ts#L678)

Replacement texture set for this tile.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-14)

[`TileAssetOptions`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/).[`textureSet`](/declarative-hex-worlds/reference/index/interfaces/tileassetoptions/#textureset)

# GameboardRecipePlanOptionsOverride

> **GameboardRecipePlanOptionsOverride** = `Partial`<[`GameboardPlanOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplanoptions/)>

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:362](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L362)

Partial plan-option override accepted when compiling a recipe.

# GameboardRecipeStep

> **GameboardRecipeStep** = [`SetTerrainRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/setterrainrecipestep/) | [`SetTileAssetRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/settileassetrecipestep/) | [`SetElevationRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/setelevationrecipestep/) | [`SetTextureSetRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/settexturesetrecipestep/) | [`SetCoastEdgesRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/setcoastedgesrecipestep/) | [`AddRoadPathRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addroadpathrecipestep/) | [`AddRiverPathRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addriverpathrecipestep/) | [`AddMountainStackRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addmountainstackrecipestep/) | [`AddHillRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addhillrecipestep/) | [`AddForestRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addforestrecipestep/) | [`AddFactionBuildingRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addfactionbuildingrecipestep/) | [`AddNeutralStructureRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addneutralstructurerecipestep/) | [`AddBridgeRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addbridgerecipestep/) | [`AddFortificationRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addfortificationrecipestep/) | [`AddConstructionSiteRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addconstructionsiterecipestep/) | [`AddSiegeProjectileRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addsiegeprojectilerecipestep/) | [`AddElevationRampRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addelevationramprecipestep/) | [`AddNatureRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addnaturerecipestep/) | [`AddPropRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addproprecipestep/) | [`AddPropClusterRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addpropclusterrecipestep/) | [`AddFlagRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addflagrecipestep/) | [`AddPlacementRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addplacementrecipestep/) | [`AddTransitionRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addtransitionrecipestep/) | [`AddUnitRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addunitrecipestep/) | [`AddUnitPresetRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addunitpresetrecipestep/) | [`AddHarborRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/addharborrecipestep/) | [`ScatterDecorationsRecipeStep`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/scatterdecorationsrecipestep/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L88)

Discriminated union of all recipe actions supported by the builder adapter.

# RecipeGenerationApplier

> **RecipeGenerationApplier** = (`plan`, `generation`) => [`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:433](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L433)

Applies a recipe’s seeded generation block to a built plan. The runtime tier injects a koota-backed applier (`applyGameboardRecipeGeneration` from `./recipe-generation`); `./core` uses the pure default below.

## Parameters

[Section titled “Parameters”](#parameters)

### plan

[Section titled “plan”](#plan)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

### generation

[Section titled “generation”](#generation)

[`GameboardRecipeGeneration`](/declarative-hex-worlds/reference/scenario/recipe/interfaces/gameboardrecipegeneration/) | `undefined`

## Returns

[Section titled “Returns”](#returns)

[`GameboardPlan`](/declarative-hex-worlds/reference/index/interfaces/gameboardplan/)

# GAMEBOARD_RECIPE_SCHEMA_VERSION

> `const` **GAMEBOARD\_RECIPE\_SCHEMA\_VERSION**: `"1.0.0"` = `'1.0.0'`

Defined in: [packages/declarative-hex-worlds/src/scenario/recipe.ts:59](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/recipe.ts#L59)

Current schema version for serialized gameboard recipes.

# analyzeHexTileRegistry

> **analyzeHexTileRegistry**(`registry`): [`TileRegistryAnalysis`](/declarative-hex-worlds/reference/scenario/registry/interfaces/tileregistryanalysis/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:361](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L361)

Analyzes registry-wide tile sizing, scale recommendations, and compatibility warnings.

## Parameters

[Section titled “Parameters”](#parameters)

### registry

[Section titled “registry”](#registry)

[`HexTileRegistry`](/declarative-hex-worlds/reference/scenario/registry/interfaces/hextileregistry/)

## Returns

[Section titled “Returns”](#returns)

[`TileRegistryAnalysis`](/declarative-hex-worlds/reference/scenario/registry/interfaces/tileregistryanalysis/)

# analyzeTileGeometry

> **analyzeTileGeometry**(`declaration`): [`TileGeometryAnalysis`](/declarative-hex-worlds/reference/scenario/registry/interfaces/tilegeometryanalysis/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:299](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L299)

Analyzes one declaration footprint against the canonical KayKit hex footprint.

## Parameters

[Section titled “Parameters”](#parameters)

### declaration

[Section titled “declaration”](#declaration)

`Pick`<[`HexTileDeclaration`](/declarative-hex-worlds/reference/scenario/registry/interfaces/hextiledeclaration/), `"id"` | `"assetId"` | `"bounds"` | `"geometry"`> & `Partial`<`Pick`<[`HexTileDeclaration`](/declarative-hex-worlds/reference/scenario/registry/interfaces/hextiledeclaration/), `"role"`>>

## Returns

[Section titled “Returns”](#returns)

[`TileGeometryAnalysis`](/declarative-hex-worlds/reference/scenario/registry/interfaces/tilegeometryanalysis/)

# applyTileDeclaration

> **applyTileDeclaration**(`builder`, `registry`, `options`): [`GameboardBuilder`](/declarative-hex-worlds/reference/index/classes/gameboardbuilder/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:405](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L405)

Applies a registered declaration to a builder as either a base tile or feature placement.

## Parameters

[Section titled “Parameters”](#parameters)

### builder

[Section titled “builder”](#builder)

[`GameboardBuilder`](/declarative-hex-worlds/reference/index/classes/gameboardbuilder/)

### registry

[Section titled “registry”](#registry)

[`HexTileRegistry`](/declarative-hex-worlds/reference/scenario/registry/interfaces/hextileregistry/)

### options

[Section titled “options”](#options)

[`ApplyTileDeclarationOptions`](/declarative-hex-worlds/reference/scenario/registry/interfaces/applytiledeclarationoptions/)

## Returns

[Section titled “Returns”](#returns)

[`GameboardBuilder`](/declarative-hex-worlds/reference/index/classes/gameboardbuilder/)

# createHexTileRegistry

> **createHexTileRegistry**(`declarations`): [`HexTileRegistry`](/declarative-hex-worlds/reference/scenario/registry/interfaces/hextileregistry/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:264](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L264)

Creates a lookup registry and reports duplicate id or asset-id warnings.

## Parameters

[Section titled “Parameters”](#parameters)

### declarations

[Section titled “declarations”](#declarations)

readonly [`HexTileDeclarationInput`](/declarative-hex-worlds/reference/scenario/registry/interfaces/hextiledeclarationinput/)\[]

## Returns

[Section titled “Returns”](#returns)

[`HexTileRegistry`](/declarative-hex-worlds/reference/scenario/registry/interfaces/hextileregistry/)

# createHexTileRegistryFromManifest

> **createHexTileRegistryFromManifest**(`manifest`): [`HexTileRegistry`](/declarative-hex-worlds/reference/scenario/registry/interfaces/hextileregistry/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:290](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L290)

Creates a tile registry from all tile assets in a medieval hexagon manifest.

## Parameters

[Section titled “Parameters”](#parameters)

### manifest

[Section titled “manifest”](#manifest)

[`MedievalHexagonManifest`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifest/)

## Returns

[Section titled “Returns”](#returns)

[`HexTileRegistry`](/declarative-hex-worlds/reference/scenario/registry/interfaces/hextileregistry/)

# declareHexTile

> **declareHexTile**(`input`): [`HexTileDeclaration`](/declarative-hex-worlds/reference/scenario/registry/interfaces/hextiledeclaration/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:230](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L230)

Normalizes a tile declaration input using KayKit defaults and inferred roles.

## Parameters

[Section titled “Parameters”](#parameters)

### input

[Section titled “input”](#input)

[`HexTileDeclarationInput`](/declarative-hex-worlds/reference/scenario/registry/interfaces/hextiledeclarationinput/)

## Returns

[Section titled “Returns”](#returns)

[`HexTileDeclaration`](/declarative-hex-worlds/reference/scenario/registry/interfaces/hextiledeclaration/)

# ApplyTileDeclarationOptions

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:208](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L208)

Options for placing a registered declaration into a gameboard builder.

## Properties

[Section titled “Properties”](#properties)

### at

[Section titled “at”](#at)

> **at**: [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:210](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L210)

Target hex coordinate.

***

### declaration

[Section titled “declaration”](#declaration)

> **declaration**: `string` | [`HexTileDeclaration`](/declarative-hex-worlds/reference/scenario/registry/interfaces/hextiledeclaration/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:212](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L212)

Declaration object, declaration id, or manifest asset id.

***

### elevation?

[Section titled “elevation?”](#elevation)

> `optional` **elevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:218](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L218)

Elevation override for base/support declarations.

***

### kind?

[Section titled “kind?”](#kind)

> `optional` **kind?**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:222](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L222)

Placement kind override for non-base declarations.

***

### layer?

[Section titled “layer?”](#layer)

> `optional` **layer?**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:224](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L224)

Placement layer override for non-base declarations.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:226](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L226)

Additional serializable metadata merged into non-base placements.

***

### rotationSteps?

[Section titled “rotationSteps?”](#rotationsteps)

> `optional` **rotationSteps?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:214](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L214)

Clockwise 60-degree rotation steps to apply to placement and edge masks.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:220](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L220)

Scale override for non-base placements.

***

### terrain?

[Section titled “terrain?”](#terrain)

> `optional` **terrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:216](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L216)

Terrain override for base/support declarations.

# HexTileDeclaration

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:114](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L114)

Normalized tile declaration stored in a registry.

## Properties

[Section titled “Properties”](#properties)

### adjacency

[Section titled “adjacency”](#adjacency)

> **adjacency**: readonly [`TileAdjacencyRule`](/declarative-hex-worlds/reference/scenario/registry/interfaces/tileadjacencyrule/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L136)

Adjacency rules consumed by validation and generators.

***

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:118](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L118)

Manifest asset id to place when this declaration is applied.

***

### bounds?

[Section titled “bounds?”](#bounds)

> `optional` **bounds?**: [`AssetBounds`](/declarative-hex-worlds/reference/types/interfaces/assetbounds/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:128](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L128)

Asset bounds used by geometry analysis and compatibility warnings.

***

### edges

[Section titled “edges”](#edges)

> **edges**: readonly [`TileEdgeDeclaration`](/declarative-hex-worlds/reference/scenario/registry/interfaces/tileedgedeclaration/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L134)

Normalized edge connection masks.

***

### geometry

[Section titled “geometry”](#geometry)

> **geometry**: [`HexGeometry`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/hexgeometry/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L130)

Complete hex footprint geometry for placement and scaling calculations.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:116](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L116)

Stable declaration id used by recipes and registry lookups.

***

### metadata

[Section titled “metadata”](#metadata)

> **metadata**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:142](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L142)

Additional serializable metadata to copy onto placements.

***

### role

[Section titled “role”](#role)

> **role**: [`TileDeclarationRole`](/declarative-hex-worlds/reference/scenario/registry/type-aliases/tiledeclarationrole/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:122](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L122)

Board construction role for the declaration.

***

### scale

[Section titled “scale”](#scale)

> **scale**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:132](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L132)

Default placement scale for feature/unit declarations.

***

### source

[Section titled “source”](#source)

> **source**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:120](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L120)

Human-readable source label, commonly `manifest`, `extra`, or a pack id.

***

### stack

[Section titled “stack”](#stack)

> **stack**: [`TileStackRule`](/declarative-hex-worlds/reference/scenario/registry/interfaces/tilestackrule/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:138](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L138)

Stacking behavior for elevation/support placement.

***

### tags

[Section titled “tags”](#tags)

> **tags**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:140](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L140)

Search and selection tags attached to the declaration.

***

### terrain?

[Section titled “terrain?”](#terrain)

> `optional` **terrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:124](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L124)

Default terrain assigned when the declaration becomes the base tile.

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:126](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L126)

Texture set associated with the declaration when it came from a pack variant.

# HexTileDeclarationInput

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:82](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L82)

Author input for registering KayKit-compatible or custom hex pieces.

## Properties

[Section titled “Properties”](#properties)

### adjacency?

[Section titled “adjacency?”](#adjacency)

> `optional` **adjacency?**: readonly [`TileAdjacencyRule`](/declarative-hex-worlds/reference/scenario/registry/interfaces/tileadjacencyrule/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:104](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L104)

Adjacency rules consumed by validation and generators.

***

### assetId?

[Section titled “assetId?”](#assetid)

> `optional` **assetId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:86](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L86)

Manifest asset id to place when this declaration is applied.

***

### bounds?

[Section titled “bounds?”](#bounds)

> `optional` **bounds?**: [`AssetBounds`](/declarative-hex-worlds/reference/types/interfaces/assetbounds/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:96](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L96)

Asset bounds used by geometry analysis and compatibility warnings.

***

### edges?

[Section titled “edges?”](#edges)

> `optional` **edges?**: `Partial`<`Record`<`string`, [`HexEdgeInput`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeinput/)>>

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:102](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L102)

Edge connection masks keyed by channel.

***

### geometry?

[Section titled “geometry?”](#geometry)

> `optional` **geometry?**: `Partial`<[`HexGeometry`](/declarative-hex-worlds/reference/coordinates/grid/interfaces/hexgeometry/)>

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:98](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L98)

Hex footprint geometry for placement and scaling calculations.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:84](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L84)

Stable declaration id used by recipes and registry lookups.

***

### metadata?

[Section titled “metadata?”](#metadata)

> `optional` **metadata?**: `Readonly`<`Record`<`string`, `string` | `number` | `boolean` | `null`>>

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:110](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L110)

Additional serializable metadata to copy onto placements.

***

### role?

[Section titled “role?”](#role)

> `optional` **role?**: [`TileDeclarationRole`](/declarative-hex-worlds/reference/scenario/registry/type-aliases/tiledeclarationrole/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:90](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L90)

Board construction role for the declaration.

***

### scale?

[Section titled “scale?”](#scale)

> `optional` **scale?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:100](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L100)

Default placement scale for feature/unit declarations.

***

### source?

[Section titled “source?”](#source)

> `optional` **source?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L88)

Human-readable source label, commonly `manifest`, `extra`, or a pack id.

***

### stack?

[Section titled “stack?”](#stack)

> `optional` **stack?**: `Partial`<[`TileStackRule`](/declarative-hex-worlds/reference/scenario/registry/interfaces/tilestackrule/)>

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:106](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L106)

Stacking behavior overrides.

***

### tags?

[Section titled “tags?”](#tags)

> `optional` **tags?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:108](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L108)

Search and selection tags attached to the declaration.

***

### terrain?

[Section titled “terrain?”](#terrain)

> `optional` **terrain?**: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:92](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L92)

Default terrain assigned when the declaration becomes the base tile.

***

### textureSet?

[Section titled “textureSet?”](#textureset)

> `optional` **textureSet?**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:94](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L94)

Texture set associated with the declaration when it came from a pack variant.

# HexTileRegistry

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:146](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L146)

Lookup structure for registered tile declarations plus normalization warnings.

## Properties

[Section titled “Properties”](#properties)

### byAssetId

[Section titled “byAssetId”](#byassetid)

> **byAssetId**: `Readonly`<`Record`<`string`, [`HexTileDeclaration`](/declarative-hex-worlds/reference/scenario/registry/interfaces/hextiledeclaration/)>>

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:152](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L152)

Declarations indexed by manifest asset id.

***

### byId

[Section titled “byId”](#byid)

> **byId**: `Readonly`<`Record`<`string`, [`HexTileDeclaration`](/declarative-hex-worlds/reference/scenario/registry/interfaces/hextiledeclaration/)>>

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:150](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L150)

Declarations indexed by declaration id.

***

### declarations

[Section titled “declarations”](#declarations)

> **declarations**: readonly [`HexTileDeclaration`](/declarative-hex-worlds/reference/scenario/registry/interfaces/hextiledeclaration/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:148](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L148)

All normalized declarations in insertion order.

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:154](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L154)

Non-fatal duplicate or compatibility warnings emitted while creating the registry.

# TileAdjacencyRule

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:54](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L54)

Adjacency rule attached to a tile declaration for validation and generation.

## Properties

[Section titled “Properties”](#properties)

### allowOffBoard?

[Section titled “allowOffBoard?”](#allowoffboard)

> `optional` **allowOffBoard?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:66](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L66)

Allows masked edges to face outside the board instead of another tile.

***

### channel

[Section titled “channel”](#channel)

> **channel**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:56](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L56)

Connection channel that the rule applies to.

***

### forbidsNeighborTerrain?

[Section titled “forbidsNeighborTerrain?”](#forbidsneighborterrain)

> `optional` **forbidsNeighborTerrain?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:64](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L64)

Neighbor terrain values that are rejected for the masked edges.

***

### mask

[Section titled “mask”](#mask)

> **mask**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:58](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L58)

Six-bit clockwise edge mask the rule constrains.

***

### reciprocal?

[Section titled “reciprocal?”](#reciprocal)

> `optional` **reciprocal?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:60](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L60)

Whether neighbors should satisfy the same channel in the opposite direction.

***

### requiresNeighborTerrain?

[Section titled “requiresNeighborTerrain?”](#requiresneighborterrain)

> `optional` **requiresNeighborTerrain?**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:62](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L62)

Neighbor terrain values that are allowed for the masked edges.

# TileEdgeDeclaration

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:44](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L44)

Normalized edge mask for a connection channel on a registered tile.

## Properties

[Section titled “Properties”](#properties)

### channel

[Section titled “channel”](#channel)

> **channel**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:46](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L46)

Connection channel, such as `road`, `river`, or `coast`.

***

### mask

[Section titled “mask”](#mask)

> **mask**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:48](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L48)

Six-bit clockwise edge mask after canonicalization.

***

### reciprocal

[Section titled “reciprocal”](#reciprocal)

> **reciprocal**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:50](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L50)

Whether neighboring tiles are expected to expose a matching edge.

# TileGeometryAnalysis

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:158](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L158)

Per-tile footprint and scaling analysis for compatibility diagnostics.

## Properties

[Section titled “Properties”](#properties)

### aspectRatio

[Section titled “aspectRatio”](#aspectratio)

> **aspectRatio**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:172](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L172)

Width divided by depth for footprint compatibility checks.

***

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:162](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L162)

Manifest asset id that was analyzed.

***

### center

[Section titled “center”](#center)

> **center**: readonly \[`number`, `number`, `number`]

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:170](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L170)

Bounds center in source asset coordinates.

***

### depth

[Section titled “depth”](#depth)

> **depth**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:166](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L166)

Bounds depth in source asset units.

***

### height

[Section titled “height”](#height)

> **height**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:168](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L168)

Bounds height in source asset units.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:160](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L160)

Declaration id that was analyzed.

***

### recommendedScale

[Section titled “recommendedScale”](#recommendedscale)

> **recommendedScale**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:178](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L178)

Median of width and depth scale recommendations.

***

### rowSpacing

[Section titled “rowSpacing”](#rowspacing)

> **rowSpacing**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:180](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L180)

Row spacing implied by the analyzed depth and recommended scale.

***

### scaleToKayKitDepth

[Section titled “scaleToKayKitDepth”](#scaletokaykitdepth)

> **scaleToKayKitDepth**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:176](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L176)

Scale required to match the KayKit canonical depth.

***

### scaleToKayKitWidth

[Section titled “scaleToKayKitWidth”](#scaletokaykitwidth)

> **scaleToKayKitWidth**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:174](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L174)

Scale required to match the KayKit canonical width.

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:182](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L182)

Non-fatal warnings for this declaration.

***

### width

[Section titled “width”](#width)

> **width**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:164](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L164)

Bounds width in source asset units.

# TileRegistryAnalysis

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:186](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L186)

Aggregate footprint and scaling analysis for an entire registry.

## Properties

[Section titled “Properties”](#properties)

### analyzedCount

[Section titled “analyzedCount”](#analyzedcount)

> **analyzedCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:190](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L190)

Number of declarations with usable bounds.

***

### medianDepth

[Section titled “medianDepth”](#mediandepth)

> **medianDepth**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:196](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L196)

Median source depth for base/support tile footprints.

***

### medianHeight

[Section titled “medianHeight”](#medianheight)

> **medianHeight**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:198](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L198)

Median source height for base/support tile footprints.

***

### medianWidth

[Section titled “medianWidth”](#medianwidth)

> **medianWidth**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:194](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L194)

Median source width for base/support tile footprints.

***

### recommendedScale

[Section titled “recommendedScale”](#recommendedscale)

> **recommendedScale**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:192](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L192)

Median scale recommendation for base/support tile footprints.

***

### rowSpacing

[Section titled “rowSpacing”](#rowspacing)

> **rowSpacing**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:200](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L200)

Row spacing implied by the median depth and recommended scale.

***

### tileCount

[Section titled “tileCount”](#tilecount)

> **tileCount**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:188](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L188)

Number of declarations in the registry.

***

### tiles

[Section titled “tiles”](#tiles)

> **tiles**: readonly [`TileGeometryAnalysis`](/declarative-hex-worlds/reference/scenario/registry/interfaces/tilegeometryanalysis/)\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:204](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L204)

Per-tile analysis entries.

***

### warnings

[Section titled “warnings”](#warnings)

> **warnings**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:202](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L202)

Registry and per-tile warnings flattened for display.

# TileStackRule

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:70](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L70)

Stacking behavior for a registered tile declaration.

## Properties

[Section titled “Properties”](#properties)

### canStack

[Section titled “canStack”](#canstack)

> **canStack**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:72](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L72)

Whether this declaration may be used as a vertical stack/support piece.

***

### heightStep?

[Section titled “heightStep?”](#heightstep)

> `optional` **heightStep?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:78](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L78)

World-space Y increment for each stacked elevation step.

***

### maxElevation?

[Section titled “maxElevation?”](#maxelevation)

> `optional` **maxElevation?**: `number`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:74](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L74)

Maximum supported elevation for repeated stack placement.

***

### supportAssetId?

[Section titled “supportAssetId?”](#supportassetid)

> `optional` **supportAssetId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:76](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L76)

Asset to use as the support piece when this declaration is a visible top.

# TileDeclarationRole

> **TileDeclarationRole** = `"base"` | `"support"` | `"surface"` | `"road"` | `"river"` | `"coast"` | `"decoration"` | `"structure"` | `"unit"` | `"custom"`

Defined in: [packages/declarative-hex-worlds/src/scenario/registry.ts:31](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/scenario/registry.ts#L31)

Describes how a registered tile-like declaration participates in board construction.

# canPlaceHarborAt

> **canPlaceHarborAt**(`world`, `coordinates`, `facing`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/systems/world-rules-system.ts:38](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/world-rules-system.ts#L38)

Checks whether a harbor may face water from the requested world tile.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### coordinates

[Section titled “coordinates”](#coordinates)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### facing

[Section titled “facing”](#facing)

`number`

## Returns

[Section titled “Returns”](#returns)

`boolean`

# canStackAt

> **canStackAt**(`world`, `coordinates`, `height`, `config?`): `boolean`

Defined in: [packages/declarative-hex-worlds/src/systems/world-rules-system.ts:27](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/world-rules-system.ts#L27)

Checks whether a world tile can support the requested elevation.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### height

[Section titled “height”](#height)

`number`

### config?

[Section titled “config?”](#config)

[`GameboardRuleConfig`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleconfig/) = `{}`

## Returns

[Section titled “Returns”](#returns)

`boolean`

# setTileElevation

> **setTileElevation**(`world`, `coordinates`, `elevation`): `void`

Defined in: [packages/declarative-hex-worlds/src/systems/world-rules-system.ts:59](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/world-rules-system.ts#L59)

Mutates the elevation state for one tile entity in a Koota world.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### elevation

[Section titled “elevation”](#elevation)

`number`

## Returns

[Section titled “Returns”](#returns)

`void`

# setTileTerrain

> **setTileTerrain**(`world`, `coordinates`, `terrain`): `void`

Defined in: [packages/declarative-hex-worlds/src/systems/world-rules-system.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/world-rules-system.ts#L45)

Mutates the terrain state for one tile entity in a Koota world.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### coordinates

[Section titled “coordinates”](#coordinates)

`string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### terrain

[Section titled “terrain”](#terrain)

[`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/)

## Returns

[Section titled “Returns”](#returns)

`void`

# validateGameboardRules

> **validateGameboardRules**(`world`, `config?`): [`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

Defined in: [packages/declarative-hex-worlds/src/systems/world-rules-system.ts:19](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/systems/world-rules-system.ts#L19)

Validates the current Koota world by projecting it into a validation plan.

## Parameters

[Section titled “Parameters”](#parameters)

### world

[Section titled “world”](#world)

`World`

### config?

[Section titled “config?”](#config)

[`GameboardRuleConfig`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleconfig/) = `{}`

## Returns

[Section titled “Returns”](#returns)

[`GameboardRuleViolation`](/declarative-hex-worlds/reference/rules/rule-types/interfaces/gameboardruleviolation/)\[]

# applyPlacementShading

> **applyPlacementShading**(`object`, `tint`, `opacity`): `void`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:671](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L671)

Apply optional per-placement shading (tint / opacity) to every material in a loaded GLTF model, mirroring the tileset-cell path so 3D units/props can be fog-shrouded / team-tinted the same way tiles are. Both are opt-in: when neither is set the materials are untouched (the model renders byte-identically). A tint multiplies each material’s `color`; an `opacity < 1` makes it translucent. The cloned model owns its materials (SkeletonUtils clone), so mutating them here does not leak into the shared cached scene’s materials — except that three’s GLTF loader may SHARE a material instance across meshes/clones, so we clone each material before mutating to keep the shading strictly per-placement.

## Parameters

[Section titled “Parameters”](#parameters)

### object

[Section titled “object”](#object)

`Object3D`

### tint

[Section titled “tint”](#tint)

{ `b`: `number`; `g`: `number`; `r`: `number`; } | `undefined`

### opacity

[Section titled “opacity”](#opacity)

`number` | `undefined`

## Returns

[Section titled “Returns”](#returns)

`void`

# applyTextureBinding

> **applyTextureBinding**(`modelRoot`, `binding`, `texture`, `normalTexture?`): [`TextureBindingResult`](/declarative-hex-worlds/reference/three/interfaces/texturebindingresult/)

Defined in: [packages/declarative-hex-worlds/src/three/texture-binding.ts:43](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/texture-binding.ts#L43)

Apply a texture binding to a loaded model. Traverses `modelRoot`, and for every mesh whose name is targeted by the binding (a binding with no `targets` matches all meshes), sets the base-color `map` (and `normalMap` when a normal texture is given) on its material(s). Returns how many materials were updated.

## Parameters

[Section titled “Parameters”](#parameters)

### modelRoot

[Section titled “modelRoot”](#modelroot)

`Object3D`

### binding

[Section titled “binding”](#binding)

[`TextureBinding`](/declarative-hex-worlds/reference/index/interfaces/texturebinding/)

### texture

[Section titled “texture”](#texture)

`Texture`

### normalTexture?

[Section titled “normalTexture?”](#normaltexture)

`Texture`<`unknown`, `TextureEventMap`>

## Returns

[Section titled “Returns”](#returns)

[`TextureBindingResult`](/declarative-hex-worlds/reference/three/interfaces/texturebindingresult/)

# applyTransform

> **applyTransform**(`object`, `transform`): `Object3D`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:654](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L654)

Applies a gameboard transform to a Three.js object.

## Parameters

[Section titled “Parameters”](#parameters)

### object

[Section titled “object”](#object)

`Object3D`

### transform

[Section titled “transform”](#transform)

[`AssetTransform`](/declarative-hex-worlds/reference/index/interfaces/assettransform/)

## Returns

[Section titled “Returns”](#returns)

`Object3D`

# attachAccessoryToModel

> **attachAccessoryToModel**(`characterRoot`, `attachment`, `accessoryObject`): [`AccessoryAttachmentResult`](/declarative-hex-worlds/reference/three/interfaces/accessoryattachmentresult/)

Defined in: [packages/declarative-hex-worlds/src/three/accessories.ts:31](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/accessories.ts#L31)

Attach `accessoryObject` to the `attachment.node` bone/node of `characterRoot`, applying the accessory’s local transform. Returns whether the node was found. On a miss the accessory is left un-parented and `attached` is false — the caller decides whether a missing node is fatal (validate at author time via `validateAccessoryAttachments`).

## Parameters

[Section titled “Parameters”](#parameters)

### characterRoot

[Section titled “characterRoot”](#characterroot)

`Object3D`

### attachment

[Section titled “attachment”](#attachment)

[`AccessoryAttachment`](/declarative-hex-worlds/reference/index/interfaces/accessoryattachment/)

### accessoryObject

[Section titled “accessoryObject”](#accessoryobject)

`Object3D`

## Returns

[Section titled “Returns”](#returns)

[`AccessoryAttachmentResult`](/declarative-hex-worlds/reference/three/interfaces/accessoryattachmentresult/)

# buildHexGeometry

> **buildHexGeometry**(`cell`, `hex`, `sheetWidth`, `sheetHeight`, `orientation?`): `BufferGeometry`

Defined in: [packages/declarative-hex-worlds/src/three/textured-hex.ts:90](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/textured-hex.ts#L90)

Build a hexagon `BufferGeometry` in the XZ plane (Y=0), with UVs mapping each corner + center to the given cell rect of a sheet. The hex spans `hex.width` on X and `hex.height` on Z.

## Parameters

[Section titled “Parameters”](#parameters)

### cell

[Section titled “cell”](#cell)

[`CellRect`](/declarative-hex-worlds/reference/index/interfaces/cellrect/)

### hex

[Section titled “hex”](#hex)

[`HexDims`](/declarative-hex-worlds/reference/index/interfaces/hexdims/)

### sheetWidth

[Section titled “sheetWidth”](#sheetwidth)

`number`

### sheetHeight

[Section titled “sheetHeight”](#sheetheight)

`number`

### orientation?

[Section titled “orientation?”](#orientation)

`"pointy"` | `"flat"`

## Returns

[Section titled “Returns”](#returns)

`BufferGeometry`

# buildTexturedHexMesh

> **buildTexturedHexMesh**(`options`): `Mesh`

Defined in: [packages/declarative-hex-worlds/src/three/textured-hex.ts:182](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/textured-hex.ts#L182)

Build a textured `Mesh` for a tileset-cell render request. Defaults to a full quad (`shape: 'quad'`) — the seamless path for transparent-corner painterly hex atlases; `shape: 'hex'` clips to a hexagon for opaque edge-to-edge cells. Sampled with a `MeshBasicMaterial` over the cell. The caller owns the returned mesh’s lifecycle (position it on the board, add to the scene, dispose on removal).

## Parameters

[Section titled “Parameters”](#parameters)

### options

[Section titled “options”](#options)

[`TexturedHexMeshOptions`](/declarative-hex-worlds/reference/three/interfaces/texturedhexmeshoptions/)

## Returns

[Section titled “Returns”](#returns)

`Mesh`

# detachAccessory

> **detachAccessory**(`accessoryObject`): `void`

Defined in: [packages/declarative-hex-worlds/src/three/accessories.ts:49](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/accessories.ts#L49)

Detach a previously-attached accessory from its parent node.

## Parameters

[Section titled “Parameters”](#parameters)

### accessoryObject

[Section titled “accessoryObject”](#accessoryobject)

`Object3D`

## Returns

[Section titled “Returns”](#returns)

`void`

# findGameboardPlacementObjectUserData

> **findGameboardPlacementObjectUserData**(`object`): [`GameboardObjectUserData`](/declarative-hex-worlds/reference/three/interfaces/gameboardobjectuserdata/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:598](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L598)

Walks up the parent chain to find gameboard user data for a picked object.

## Parameters

[Section titled “Parameters”](#parameters)

### object

[Section titled “object”](#object)

`Object3D`

## Returns

[Section titled “Returns”](#returns)

[`GameboardObjectUserData`](/declarative-hex-worlds/reference/three/interfaces/gameboardobjectuserdata/) | `undefined`

# findLoadedGameboardPlacementObjectForObject

> **findLoadedGameboardPlacementObjectForObject**(`object`, `records`): [`LoadedGameboardPlacementObject`](/declarative-hex-worlds/reference/three/interfaces/loadedgameboardplacementobject/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:615](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L615)

Resolves a picked object back to the loaded placement record cache.

## Parameters

[Section titled “Parameters”](#parameters)

### object

[Section titled “object”](#object)

`Object3D`

### records

[Section titled “records”](#records)

`ReadonlyMap`<`string`, [`LoadedGameboardPlacementObject`](/declarative-hex-worlds/reference/three/interfaces/loadedgameboardplacementobject/)>

## Returns

[Section titled “Returns”](#returns)

[`LoadedGameboardPlacementObject`](/declarative-hex-worlds/reference/three/interfaces/loadedgameboardplacementobject/) | `undefined`

# frameObjectPosition

> **frameObjectPosition**(`asset`, `margin?`): `Vector3`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:732](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L732)

Returns a camera-friendly offset for framing one manifest asset preview.

## Parameters

[Section titled “Parameters”](#parameters)

### asset

[Section titled “asset”](#asset)

[`MedievalHexagonAsset`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonasset/)

### margin?

[Section titled “margin?”](#margin)

`number` = `1.7`

## Returns

[Section titled “Returns”](#returns)

`Vector3`

# gameboardInteractionTargetForObject

> **gameboardInteractionTargetForObject**(`object`): [`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:627](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L627)

Converts picked Three.js object metadata into an actor/placement/tile target for command and interaction helpers.

## Parameters

[Section titled “Parameters”](#parameters)

### object

[Section titled “object”](#object)

`Object3D`

## Returns

[Section titled “Returns”](#returns)

[`GameboardInteractionTargetInput`](/declarative-hex-worlds/reference/index/type-aliases/gameboardinteractiontargetinput/) | `undefined`

# loadGameboardPlacementObject

> **loadGameboardPlacementObject**(`placement`, `options`): `Promise`<[`LoadedGameboardPlacementObject`](/declarative-hex-worlds/reference/three/interfaces/loadedgameboardplacementobject/)>

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:362](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L362)

## Parameters

[Section titled “Parameters”](#parameters)

### placement

[Section titled “placement”](#placement)

[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

### options

[Section titled “options”](#options)

[`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/)

## Returns

[Section titled “Returns”](#returns)

`Promise`<[`LoadedGameboardPlacementObject`](/declarative-hex-worlds/reference/three/interfaces/loadedgameboardplacementobject/)>

# placeObjectOnHex

> **placeObjectOnHex**(`object`, `coordinates`, `options?`): `Object3D`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:716](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L716)

Places an object directly on a board hex without creating a placement record.

## Parameters

[Section titled “Parameters”](#parameters)

### object

[Section titled “object”](#object)

`Object3D`

### coordinates

[Section titled “coordinates”](#coordinates)

[`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

### options?

[Section titled “options?”](#options)

#### elevation?

[Section titled “elevation?”](#elevation)

`number`

#### positionOffset?

[Section titled “positionOffset?”](#positionoffset)

[`GameboardPlacementPositionOffset`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementpositionoffset/)

#### rotationY?

[Section titled “rotationY?”](#rotationy)

`number`

#### scale?

[Section titled “scale?”](#scale)

`number`

## Returns

[Section titled “Returns”](#returns)

`Object3D`

# readGameboardPlacementObjectUserData

> **readGameboardPlacementObjectUserData**(`object`): [`GameboardObjectUserData`](/declarative-hex-worlds/reference/three/interfaces/gameboardobjectuserdata/) | `undefined`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:587](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L587)

Reads gameboard user data directly attached to an object.

## Parameters

[Section titled “Parameters”](#parameters)

### object

[Section titled “object”](#object)

`Object3D`

## Returns

[Section titled “Returns”](#returns)

[`GameboardObjectUserData`](/declarative-hex-worlds/reference/three/interfaces/gameboardobjectuserdata/) | `undefined`

# syncGameboardPlacementObject

> **syncGameboardPlacementObject**(`loaded`, `placement`, `options?`): [`LoadedGameboardPlacementObject`](/declarative-hex-worlds/reference/three/interfaces/loadedgameboardplacementobject/)

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:550](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L550)

Updates one loaded object to match the current placement transform and user data.

## Parameters

[Section titled “Parameters”](#parameters)

### loaded

[Section titled “loaded”](#loaded)

[`LoadedGameboardPlacementObject`](/declarative-hex-worlds/reference/three/interfaces/loadedgameboardplacementobject/)

### placement

[Section titled “placement”](#placement)

[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

### options?

[Section titled “options?”](#options)

#### deltaSeconds?

[Section titled “deltaSeconds?”](#deltaseconds)

`number`

## Returns

[Section titled “Returns”](#returns)

[`LoadedGameboardPlacementObject`](/declarative-hex-worlds/reference/three/interfaces/loadedgameboardplacementobject/)

# syncGameboardPlacementObjects

> **syncGameboardPlacementObjects**(`placements`, `options`): `Promise`<[`GameboardPlacementObjectSyncResult`](/declarative-hex-worlds/reference/three/interfaces/gameboardplacementobjectsyncresult/)>

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:464](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L464)

Reconciles a Three.js object cache with the current placement list.

Existing records are updated in place, changed asset URLs are reloaded, stale records are removed by default, and load failures are returned unless `throwOnError` is set.

## Parameters

[Section titled “Parameters”](#parameters)

### placements

[Section titled “placements”](#placements)

readonly [`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)\[]

### options

[Section titled “options”](#options)

[`GameboardPlacementObjectSyncOptions`](/declarative-hex-worlds/reference/three/interfaces/gameboardplacementobjectsyncoptions/)

## Returns

[Section titled “Returns”](#returns)

`Promise`<[`GameboardPlacementObjectSyncResult`](/declarative-hex-worlds/reference/three/interfaces/gameboardplacementobjectsyncresult/)>

# tagGameboardPlacementObject

> **tagGameboardPlacementObject**(`object`, `placement`, `options?`): `Object3D`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:569](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L569)

Attaches gameboard picking metadata to a Three.js object.

## Parameters

[Section titled “Parameters”](#parameters)

### object

[Section titled “object”](#object)

`Object3D`

### placement

[Section titled “placement”](#placement)

[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

### options?

[Section titled “options?”](#options)

#### recursive?

[Section titled “recursive?”](#recursive)

`boolean`

## Returns

[Section titled “Returns”](#returns)

`Object3D`

# updateGameboardPlacementAnimation

> **updateGameboardPlacementAnimation**(`loaded`, `deltaSeconds`): `void`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:644](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L644)

Advances the animation mixer for one loaded placement object.

## Parameters

[Section titled “Parameters”](#parameters)

### loaded

[Section titled “loaded”](#loaded)

`Pick`<[`LoadedGameboardPlacementObject`](/declarative-hex-worlds/reference/three/interfaces/loadedgameboardplacementobject/), `"mixer"`>

### deltaSeconds

[Section titled “deltaSeconds”](#deltaseconds)

`number`

## Returns

[Section titled “Returns”](#returns)

`void`

# AccessoryAttachmentResult

Defined in: [packages/declarative-hex-worlds/src/three/accessories.ts:17](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/accessories.ts#L17)

Result of attaching an accessory — the node it parented to, or a miss.

## Properties

[Section titled “Properties”](#properties)

### attached

[Section titled “attached”](#attached)

> `readonly` **attached**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/three/accessories.ts:20](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/accessories.ts#L20)

True if the target node was found and the accessory parented to it.

***

### id

[Section titled “id”](#id)

> `readonly` **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/three/accessories.ts:18](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/accessories.ts#L18)

***

### node?

[Section titled “node?”](#node)

> `readonly` `optional` **node?**: `Object3D`<`Object3DEventMap`>

Defined in: [packages/declarative-hex-worlds/src/three/accessories.ts:22](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/accessories.ts#L22)

The node the accessory attached to (undefined on a miss).

# GameboardGltfLike

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:57](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L57)

Minimal GLTF loader result shape used by the renderer helpers.

## Properties

[Section titled “Properties”](#properties)

### animations?

[Section titled “animations?”](#animations)

> `optional` **animations?**: readonly `AnimationClip`\[]

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:61](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L61)

Animation clips embedded in the GLTF.

***

### scene

[Section titled “scene”](#scene)

> **scene**: `Object3D`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:59](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L59)

Root Three.js scene/object loaded from GLTF.

# GameboardGltfLoader

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L67)

Minimal async loader contract compatible with `GLTFLoader`.

## Methods

[Section titled “Methods”](#methods)

### loadAsync()

[Section titled “loadAsync()”](#loadasync)

> **loadAsync**(`url`): `Promise`<[`GameboardGltfLike`](/declarative-hex-worlds/reference/three/interfaces/gameboardgltflike/)>

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:69](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L69)

Loads a GLTF/GLB URL and returns the scene plus optional clips.

#### Parameters

[Section titled “Parameters”](#parameters)

##### url

[Section titled “url”](#url)

`string`

#### Returns

[Section titled “Returns”](#returns)

`Promise`<[`GameboardGltfLike`](/declarative-hex-worlds/reference/three/interfaces/gameboardgltflike/)>

# GameboardObjectUserData

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:257](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L257)

User-data payload attached to rendered objects for picking and interaction.

## Properties

[Section titled “Properties”](#properties)

### actorId?

[Section titled “actorId?”](#actorid)

> `optional` **actorId?**: `string`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:271](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L271)

Actor id when the placement represents a runtime actor.

***

### actorKind?

[Section titled “actorKind?”](#actorkind)

> `optional` **actorKind?**: `string`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:273](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L273)

Actor kind when supplied by placement metadata.

***

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:263](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L263)

Source asset id.

***

### kind

[Section titled “kind”](#kind)

> **kind**: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/)

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:265](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L265)

Placement kind from the gameboard plan.

***

### layer

[Section titled “layer”](#layer)

> **layer**: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/)

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:267](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L267)

Placement layer from the gameboard plan.

***

### placementId

[Section titled “placementId”](#placementid)

> **placementId**: `string`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:259](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L259)

Placement id represented by this object.

***

### requiresExtra

[Section titled “requiresExtra”](#requiresextra)

> **requiresExtra**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:269](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L269)

Whether this object depends on local EXTRA or external assets.

***

### sourcePack?

[Section titled “sourcePack?”](#sourcepack)

> `optional` **sourcePack?**: `string`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:275](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L275)

Source pack label for external pieces.

***

### tileKey

[Section titled “tileKey”](#tilekey)

> **tileKey**: `string`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:261](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L261)

Origin tile key.

# GameboardPlacementObjectSyncError

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:299](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L299)

Load/sync error for a specific placement.

## Properties

[Section titled “Properties”](#properties)

### error

[Section titled “error”](#error)

> **error**: `unknown`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:303](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L303)

Original error value.

***

### placement

[Section titled “placement”](#placement)

> **placement**: [`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:301](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L301)

Placement that failed to load or sync.

# GameboardPlacementObjectSyncOptions

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:281](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L281)

Options for reconciling a Three.js scene with a placement list.

## Extends

[Section titled “Extends”](#extends)

* [`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/)

## Properties

[Section titled “Properties”](#properties)

### animationUrlResolver?

[Section titled “animationUrlResolver?”](#animationurlresolver)

> `optional` **animationUrlResolver?**: (`placement`) => `string` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L47)

App-specific animation URL resolver.

#### Parameters

[Section titled “Parameters”](#parameters)

##### placement

[Section titled “placement”](#placement)

[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

#### Returns

[Section titled “Returns”](#returns)

`string` | `undefined`

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/).[`animationUrlResolver`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/#animationurlresolver)

***

### animationUrls?

[Section titled “animationUrls?”](#animationurls)

> `optional` **animationUrls?**: `Readonly`<`Record`<`string`, `string`>>

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L45)

Explicit asset-id-to-animation-URL map.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/).[`animationUrls`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/#animationurls)

***

### assetUrls?

[Section titled “assetUrls?”](#asseturls)

> `optional` **assetUrls?**: `Readonly`<`Record`<`string`, `string`>>

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:32](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L32)

Explicit asset-id-to-URL overrides, useful for local-only Vite `@fs` assets.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/).[`assetUrls`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/#asseturls)

***

### baseUrl?

[Section titled “baseUrl?”](#baseurl)

> `optional` **baseUrl?**: `string` | `URL`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:147](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L147)

Base URL applied to every model path when no edition-specific base exists.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/).[`baseUrl`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/#baseurl)

***

### bootstrapAssetRoot?

[Section titled “bootstrapAssetRoot?”](#bootstrapassetroot)

> `optional` **bootstrapAssetRoot?**: `string` | `URL`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:160](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L160)

Consumer’s bootstrap asset root (per PRD RB3).

When set, manifest `sourcePath` values (e.g. `buildings/blue/foo.gltf`) are joined with this root to produce the resolved URL — `<bootstrapAssetRoot>/<sourcePath>` (flat layout, no subdirectory prefix).

Honored only when neither [baseUrl](/declarative-hex-worlds/reference/manifest/schema/interfaces/manifestasseturloptions/#baseurl) nor a matching [editionBaseUrls](/declarative-hex-worlds/reference/manifest/schema/interfaces/manifestasseturloptions/#editionbaseurls) entry is set; explicit base URLs always win.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/).[`bootstrapAssetRoot`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/#bootstrapassetroot)

***

### cacheLoads?

[Section titled “cacheLoads?”](#cacheloads)

> `optional` **cacheLoads?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:225](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L225)

Deduplicates loader calls by URL so multiple placements sharing an asset trigger exactly one `loadAsync` invocation. The cached GLTF source is never mutated directly — each placement still receives its own cloned `Object3D` scene instance. Defaults to `true`.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/).[`cacheLoads`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/#cacheloads)

***

### catalog?

[Section titled “catalog?”](#catalog)

> `optional` **catalog?**: [`ManifestAssetCatalog`](/declarative-hex-worlds/reference/manifest/schema/type-aliases/manifestassetcatalog/)

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:30](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L30)

Manifest or manifest bundle used for packaged FREE/EXTRA asset ids.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/).[`catalog`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/#catalog)

***

### clipName?

[Section titled “clipName?”](#clipname)

> `optional` **clipName?**: `string`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:216](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L216)

Optional clip name override. Defaults to placement metadata when present.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/).[`clipName`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/#clipname)

***

### clipNameResolver?

[Section titled “clipNameResolver?”](#clipnameresolver)

> `optional` **clipNameResolver?**: (`placement`) => `string` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:291](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L291)

Per-placement clip-name resolver.

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### placement

[Section titled “placement”](#placement-1)

[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

#### Returns

[Section titled “Returns”](#returns-1)

`string` | `undefined`

***

### deltaSeconds?

[Section titled “deltaSeconds?”](#deltaseconds)

> `optional` **deltaSeconds?**: `number`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:289](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L289)

Optional animation delta to advance during this sync pass.

***

### editionBaseUrls?

[Section titled “editionBaseUrls?”](#editionbaseurls)

> `optional` **editionBaseUrls?**: `Partial`<`Record`<`"free"` | `"extra"`, `string` | `URL`>>

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:149](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L149)

Per-edition base URLs, useful when FREE is packaged and EXTRA is local.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-8)

[`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/).[`editionBaseUrls`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/#editionbaseurls)

***

### fallback?

[Section titled “fallback?”](#fallback)

> `optional` **fallback?**: (`placement`) => `string` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:34](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L34)

Last-chance resolver for app-specific asset stores.

#### Parameters

[Section titled “Parameters”](#parameters-2)

##### placement

[Section titled “placement”](#placement-2)

[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

#### Returns

[Section titled “Returns”](#returns-2)

`string` | `undefined`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-9)

[`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/).[`fallback`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/#fallback)

***

### loader?

[Section titled “loader?”](#loader)

> `optional` **loader?**: [`GameboardGltfLoader`](/declarative-hex-worlds/reference/three/interfaces/gameboardgltfloader/)

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:206](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L206)

GLTF-compatible async loader. OPTIONAL: only required when a placement actually resolves to a `gltf` request. A tileset-ONLY board (every placement resolves to a `tileset-cell`) needs no GLTF loader — supply only `textureLoader`. A `gltf` request with no `loader` throws a clear error at load time.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-10)

[`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/).[`loader`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/#loader)

***

### parent?

[Section titled “parent?”](#parent)

> `optional` **parent?**: `Object3D`<`Object3DEventMap`>

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:283](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L283)

Parent object to receive loaded placement objects.

***

### playAnimation?

[Section titled “playAnimation?”](#playanimation)

> `optional` **playAnimation?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:218](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L218)

Whether to start the selected animation immediately. Defaults to true.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-11)

[`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/).[`playAnimation`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/#playanimation)

***

### records?

[Section titled “records?”](#records)

> `optional` **records?**: `Map`<`string`, [`LoadedGameboardPlacementObject`](/declarative-hex-worlds/reference/three/interfaces/loadedgameboardplacementobject/)>

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:285](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L285)

Mutable cache keyed by placement id.

***

### removeStale?

[Section titled “removeStale?”](#removestale)

> `optional` **removeStale?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:287](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L287)

Remove cached objects that no longer appear in the placement list.

***

### source?

[Section titled “source?”](#source)

> `optional` **source?**: [`AssetSource`](/declarative-hex-worlds/reference/index/interfaces/assetsource/)

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:212](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L212)

Optional asset source (RFC0-7). When provided, a placement resolving to a `tileset-cell` request is rendered as a textured-hex mesh instead of a GLTF; a `gltf` request (or no resolution) falls through to the GLTF loader path.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-12)

[`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/).[`source`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/#source)

***

### textureLoader?

[Section titled “textureLoader?”](#textureloader)

> `optional` **textureLoader?**: [`GameboardSheetTextureLoader`](/declarative-hex-worlds/reference/three/interfaces/gameboardsheettextureloader/)

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:214](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L214)

Sheet-texture loader, required when `source` can emit tileset-cell requests.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-13)

[`LoadGameboardPlacementObjectOptions`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/).[`textureLoader`](/declarative-hex-worlds/reference/three/interfaces/loadgameboardplacementobjectoptions/#textureloader)

***

### throwOnError?

[Section titled “throwOnError?”](#throwonerror)

> `optional` **throwOnError?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:293](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L293)

Rethrow load errors instead of collecting them in the result.

# GameboardPlacementObjectSyncResult

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:309](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L309)

Result of a placement-object sync pass.

## Properties

[Section titled “Properties”](#properties)

### errors

[Section titled “errors”](#errors)

> **errors**: readonly [`GameboardPlacementObjectSyncError`](/declarative-hex-worlds/reference/three/interfaces/gameboardplacementobjectsyncerror/)\[]

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:319](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L319)

Non-fatal load errors collected during this pass.

***

### loaded

[Section titled “loaded”](#loaded)

> **loaded**: readonly [`LoadedGameboardPlacementObject`](/declarative-hex-worlds/reference/three/interfaces/loadedgameboardplacementobject/)\[]

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:313](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L313)

Objects loaded during this pass.

***

### records

[Section titled “records”](#records)

> **records**: `Map`<`string`, [`LoadedGameboardPlacementObject`](/declarative-hex-worlds/reference/three/interfaces/loadedgameboardplacementobject/)>

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:311](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L311)

Final mutable cache keyed by placement id.

***

### removed

[Section titled “removed”](#removed)

> **removed**: readonly [`LoadedGameboardPlacementObject`](/declarative-hex-worlds/reference/three/interfaces/loadedgameboardplacementobject/)\[]

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:317](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L317)

Objects removed during this pass.

***

### updated

[Section titled “updated”](#updated)

> **updated**: readonly [`LoadedGameboardPlacementObject`](/declarative-hex-worlds/reference/three/interfaces/loadedgameboardplacementobject/)\[]

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:315](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L315)

Existing objects updated in place during this pass.

# GameboardSheetTextureLoader

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:169](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L169)

Minimal async loader contract for tileset sheet textures. Compatible with a three `TextureLoader` wrapped to also report the sheet’s pixel dimensions (needed for per-cell UV normalization in `buildTexturedHexMesh`).

## Methods

[Section titled “Methods”](#methods)

### loadAsync()

[Section titled “loadAsync()”](#loadasync)

> **loadAsync**(`url`): `Promise`<[`SheetTexture`](/declarative-hex-worlds/reference/three/interfaces/sheettexture/)>

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:171](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L171)

Load a sheet image URL and return the texture plus its pixel dimensions.

#### Parameters

[Section titled “Parameters”](#parameters)

##### url

[Section titled “url”](#url)

`string`

#### Returns

[Section titled “Returns”](#returns)

`Promise`<[`SheetTexture`](/declarative-hex-worlds/reference/three/interfaces/sheettexture/)>

# LoadedGameboardPlacementObject

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:231](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L231)

Loaded Three.js object plus gameboard metadata and animation state.

## Properties

[Section titled “Properties”](#properties)

### activeClip?

[Section titled “activeClip?”](#activeclip)

> `optional` **activeClip?**: `AnimationClip`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:247](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L247)

Selected active clip.

***

### animationAction?

[Section titled “animationAction?”](#animationaction)

> `optional` **animationAction?**: `AnimationAction`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:251](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L251)

Action created for the active clip.

***

### animationUrl?

[Section titled “animationUrl?”](#animationurl)

> `optional` **animationUrl?**: `string`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:241](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L241)

Resolved animation URL, when separate from the model.

***

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:235](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L235)

Asset id this object was loaded from.

***

### clips

[Section titled “clips”](#clips)

> **clips**: readonly `AnimationClip`\[]

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:245](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L245)

Available animation clips from model and optional animation source.

***

### mixer?

[Section titled “mixer?”](#mixer)

> `optional` **mixer?**: `AnimationMixer`<`AnimationMixerEventMap`>

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:249](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L249)

Animation mixer bound to the loaded object.

***

### modelUrl

[Section titled “modelUrl”](#modelurl)

> **modelUrl**: `string`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:239](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L239)

Resolved model URL.

***

### object

[Section titled “object”](#object)

> **object**: `Object3D`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:237](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L237)

Three.js object added to the scene.

***

### placementId

[Section titled “placementId”](#placementid)

> **placementId**: `string`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:233](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L233)

Placement id this object represents.

***

### transform

[Section titled “transform”](#transform)

> **transform**: [`AssetTransform`](/declarative-hex-worlds/reference/index/interfaces/assettransform/)

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:243](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L243)

Last transform applied to the object.

# LoadGameboardPlacementObjectOptions

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:197](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L197)

Options for loading one placement object.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardPlacementAssetUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/).[`GameboardPlacementAnimationUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementanimationurloptions/)

## Extended by

[Section titled “Extended by”](#extended-by)

* [`GameboardPlacementObjectSyncOptions`](/declarative-hex-worlds/reference/three/interfaces/gameboardplacementobjectsyncoptions/)

## Properties

[Section titled “Properties”](#properties)

### animationUrlResolver?

[Section titled “animationUrlResolver?”](#animationurlresolver)

> `optional` **animationUrlResolver?**: (`placement`) => `string` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L47)

App-specific animation URL resolver.

#### Parameters

[Section titled “Parameters”](#parameters)

##### placement

[Section titled “placement”](#placement)

[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

#### Returns

[Section titled “Returns”](#returns)

`string` | `undefined`

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardPlacementAnimationUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementanimationurloptions/).[`animationUrlResolver`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementanimationurloptions/#animationurlresolver)

***

### animationUrls?

[Section titled “animationUrls?”](#animationurls)

> `optional` **animationUrls?**: `Readonly`<`Record`<`string`, `string`>>

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L45)

Explicit asset-id-to-animation-URL map.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardPlacementAnimationUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementanimationurloptions/).[`animationUrls`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementanimationurloptions/#animationurls)

***

### assetUrls?

[Section titled “assetUrls?”](#asseturls)

> `optional` **assetUrls?**: `Readonly`<`Record`<`string`, `string`>>

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:32](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L32)

Explicit asset-id-to-URL overrides, useful for local-only Vite `@fs` assets.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-2)

[`GameboardPlacementAssetUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/).[`assetUrls`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/#asseturls)

***

### baseUrl?

[Section titled “baseUrl?”](#baseurl)

> `optional` **baseUrl?**: `string` | `URL`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:147](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L147)

Base URL applied to every model path when no edition-specific base exists.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-3)

[`GameboardPlacementAssetUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/).[`baseUrl`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/#baseurl)

***

### bootstrapAssetRoot?

[Section titled “bootstrapAssetRoot?”](#bootstrapassetroot)

> `optional` **bootstrapAssetRoot?**: `string` | `URL`

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:160](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L160)

Consumer’s bootstrap asset root (per PRD RB3).

When set, manifest `sourcePath` values (e.g. `buildings/blue/foo.gltf`) are joined with this root to produce the resolved URL — `<bootstrapAssetRoot>/<sourcePath>` (flat layout, no subdirectory prefix).

Honored only when neither [baseUrl](/declarative-hex-worlds/reference/manifest/schema/interfaces/manifestasseturloptions/#baseurl) nor a matching [editionBaseUrls](/declarative-hex-worlds/reference/manifest/schema/interfaces/manifestasseturloptions/#editionbaseurls) entry is set; explicit base URLs always win.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-4)

[`GameboardPlacementAssetUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/).[`bootstrapAssetRoot`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/#bootstrapassetroot)

***

### cacheLoads?

[Section titled “cacheLoads?”](#cacheloads)

> `optional` **cacheLoads?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:225](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L225)

Deduplicates loader calls by URL so multiple placements sharing an asset trigger exactly one `loadAsync` invocation. The cached GLTF source is never mutated directly — each placement still receives its own cloned `Object3D` scene instance. Defaults to `true`.

***

### catalog?

[Section titled “catalog?”](#catalog)

> `optional` **catalog?**: [`ManifestAssetCatalog`](/declarative-hex-worlds/reference/manifest/schema/type-aliases/manifestassetcatalog/)

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:30](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L30)

Manifest or manifest bundle used for packaged FREE/EXTRA asset ids.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-5)

[`GameboardPlacementAssetUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/).[`catalog`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/#catalog)

***

### clipName?

[Section titled “clipName?”](#clipname)

> `optional` **clipName?**: `string`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:216](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L216)

Optional clip name override. Defaults to placement metadata when present.

***

### editionBaseUrls?

[Section titled “editionBaseUrls?”](#editionbaseurls)

> `optional` **editionBaseUrls?**: `Partial`<`Record`<`"free"` | `"extra"`, `string` | `URL`>>

Defined in: [packages/declarative-hex-worlds/src/manifest/schema.ts:149](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/manifest/schema.ts#L149)

Per-edition base URLs, useful when FREE is packaged and EXTRA is local.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-6)

[`GameboardPlacementAssetUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/).[`editionBaseUrls`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/#editionbaseurls)

***

### fallback?

[Section titled “fallback?”](#fallback)

> `optional` **fallback?**: (`placement`) => `string` | `undefined`

Defined in: [packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts:34](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/asset-source/placement-resolution.ts#L34)

Last-chance resolver for app-specific asset stores.

#### Parameters

[Section titled “Parameters”](#parameters-1)

##### placement

[Section titled “placement”](#placement-1)

[`GameboardPlacementSpec`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementspec/)

#### Returns

[Section titled “Returns”](#returns-1)

`string` | `undefined`

#### Inherited from

[Section titled “Inherited from”](#inherited-from-7)

[`GameboardPlacementAssetUrlOptions`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/).[`fallback`](/declarative-hex-worlds/reference/index/interfaces/gameboardplacementasseturloptions/#fallback)

***

### loader?

[Section titled “loader?”](#loader)

> `optional` **loader?**: [`GameboardGltfLoader`](/declarative-hex-worlds/reference/three/interfaces/gameboardgltfloader/)

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:206](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L206)

GLTF-compatible async loader. OPTIONAL: only required when a placement actually resolves to a `gltf` request. A tileset-ONLY board (every placement resolves to a `tileset-cell`) needs no GLTF loader — supply only `textureLoader`. A `gltf` request with no `loader` throws a clear error at load time.

***

### playAnimation?

[Section titled “playAnimation?”](#playanimation)

> `optional` **playAnimation?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:218](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L218)

Whether to start the selected animation immediately. Defaults to true.

***

### source?

[Section titled “source?”](#source)

> `optional` **source?**: [`AssetSource`](/declarative-hex-worlds/reference/index/interfaces/assetsource/)

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:212](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L212)

Optional asset source (RFC0-7). When provided, a placement resolving to a `tileset-cell` request is rendered as a textured-hex mesh instead of a GLTF; a `gltf` request (or no resolution) falls through to the GLTF loader path.

***

### textureLoader?

[Section titled “textureLoader?”](#textureloader)

> `optional` **textureLoader?**: [`GameboardSheetTextureLoader`](/declarative-hex-worlds/reference/three/interfaces/gameboardsheettextureloader/)

Defined in: [packages/declarative-hex-worlds/src/three/three.ts:214](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/three.ts#L214)

Sheet-texture loader, required when `source` can emit tileset-cell requests.

# SheetTexture

Defined in: [packages/declarative-hex-worlds/src/three/textured-hex.ts:30](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/textured-hex.ts#L30)

A texture whose full pixel dimensions are known (for UV normalization).

## Properties

[Section titled “Properties”](#properties)

### sheetHeight

[Section titled “sheetHeight”](#sheetheight)

> **sheetHeight**: `number`

Defined in: [packages/declarative-hex-worlds/src/three/textured-hex.ts:35](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/textured-hex.ts#L35)

Full sheet height in pixels.

***

### sheetWidth

[Section titled “sheetWidth”](#sheetwidth)

> **sheetWidth**: `number`

Defined in: [packages/declarative-hex-worlds/src/three/textured-hex.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/textured-hex.ts#L33)

Full sheet width in pixels.

***

### texture

[Section titled “texture”](#texture)

> **texture**: `Texture`

Defined in: [packages/declarative-hex-worlds/src/three/textured-hex.ts:31](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/textured-hex.ts#L31)

# TextureBindingResult

Defined in: [packages/declarative-hex-worlds/src/three/texture-binding.ts:24](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/texture-binding.ts#L24)

Result of applying a texture binding — the count of materials updated.

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> `readonly` **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/three/texture-binding.ts:25](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/texture-binding.ts#L25)

***

### materialsUpdated

[Section titled “materialsUpdated”](#materialsupdated)

> `readonly` **materialsUpdated**: `number`

Defined in: [packages/declarative-hex-worlds/src/three/texture-binding.ts:26](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/texture-binding.ts#L26)

# TexturedHexMeshOptions

Defined in: [packages/declarative-hex-worlds/src/three/textured-hex.ts:39](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/textured-hex.ts#L39)

Options for building a textured hex mesh.

## Properties

[Section titled “Properties”](#properties)

### cell

[Section titled “cell”](#cell)

> **cell**: [`CellRect`](/declarative-hex-worlds/reference/index/interfaces/cellrect/)

Defined in: [packages/declarative-hex-worlds/src/three/textured-hex.ts:41](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/textured-hex.ts#L41)

***

### doubleSide?

[Section titled “doubleSide?”](#doubleside)

> `optional` **doubleSide?**: `boolean`

Defined in: [packages/declarative-hex-worlds/src/three/textured-hex.ts:59](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/textured-hex.ts#L59)

Whether the mesh is double-sided (default: true, so top-down cameras see it).

***

### hex

[Section titled “hex”](#hex)

> **hex**: [`HexDims`](/declarative-hex-worlds/reference/index/interfaces/hexdims/)

Defined in: [packages/declarative-hex-worlds/src/three/textured-hex.ts:42](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/textured-hex.ts#L42)

***

### opacity?

[Section titled “opacity?”](#opacity)

> `optional` **opacity?**: `number`

Defined in: [packages/declarative-hex-worlds/src/three/textured-hex.ts:73](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/textured-hex.ts#L73)

Optional opacity in `[0, 1]`. `< 1` switches the material to the TRANSPARENT queue (a translucent shroud) while KEEPING `alphaTest` so the hex corners still cut out. Omitted or `>= 1` leaves the default OPAQUE-queue cutout path (`transparent: false`) byte-for-byte unchanged, preserving seamless tessellation.

***

### orientation?

[Section titled “orientation?”](#orientation)

> `optional` **orientation?**: `"pointy"` | `"flat"`

Defined in: [packages/declarative-hex-worlds/src/three/textured-hex.ts:57](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/textured-hex.ts#L57)

Hex orientation (only meaningful for `shape: 'hex'`). `'pointy'` (default) has a vertex at the top; `'flat'` has a flat edge at the top.

***

### shape?

[Section titled “shape?”](#shape)

> `optional` **shape?**: `"hex"` | `"quad"`

Defined in: [packages/declarative-hex-worlds/src/three/textured-hex.ts:52](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/textured-hex.ts#L52)

Draw shape (see `AssetRenderRequest['shape']`):

* `'quad'` (default): the full cell rect is a rectangle spanning `hex.width × hex.height`. Painterly hex atlases paint each cell as a flattened hex with TRANSPARENT corners; a full quad lets neighbours’ opaque bodies fill each other’s transparent corners, tessellating SEAMLESSLY. This matches the canvas-2D binding, which always blits the whole cell.
* `'hex'`: clip to a hexagon silhouette. Only for opaque edge-to-edge cells.

***

### sheet

[Section titled “sheet”](#sheet)

> **sheet**: [`SheetTexture`](/declarative-hex-worlds/reference/three/interfaces/sheettexture/)

Defined in: [packages/declarative-hex-worlds/src/three/textured-hex.ts:40](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/textured-hex.ts#L40)

***

### tint?

[Section titled “tint?”](#tint)

> `optional` **tint?**: `object`

Defined in: [packages/declarative-hex-worlds/src/three/textured-hex.ts:66](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/three/textured-hex.ts#L66)

Optional multiplicative RGB tint (channels `[0, 1]`, white ⇒ identity), applied to the material `color` so a game can shade a shared atlas per placement (fog-of-war / season / team). Omitted ⇒ the material keeps its default white colour (no tint).

#### b

[Section titled “b”](#b)

> **b**: `number`

#### g

[Section titled “g”](#g)

> **g**: `number`

#### r

[Section titled “r”](#r)

> **r**: `number`

# CollisionQuestObjective

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:83](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L83)

Objective completed when a collision report matches an expected state.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardQuestObjectiveBase`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/)

## Properties

[Section titled “Properties”](#properties)

### actor?

[Section titled “actor?”](#actor)

> `optional` **actor?**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:87](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L87)

Optional source actor id.

***

### expect

[Section titled “expect”](#expect)

> **expect**: [`GameboardQuestCollisionExpectation`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestcollisionexpectation/)

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:93](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L93)

Expected collision state.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L33)

Stable objective id within the quest.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardQuestObjectiveBase`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/).[`id`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/#id)

***

### kind

[Section titled “kind”](#kind)

> **kind**: `"collision"`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:85](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L85)

Objective discriminator.

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:35](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L35)

Optional display label.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardQuestObjectiveBase`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/).[`label`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/#label)

***

### targetActor?

[Section titled “targetActor?”](#targetactor)

> `optional` **targetActor?**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:89](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L89)

Optional target actor id.

***

### targetTile?

[Section titled “targetTile?”](#targettile)

> `optional` **targetTile?**: `string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:91](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L91)

Optional target tile coordinates or tile key.

# DefeatActorQuestObjective

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:75](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L75)

Objective completed when a target actor no longer exists.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardQuestObjectiveBase`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/)

## Properties

[Section titled “Properties”](#properties)

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L33)

Stable objective id within the quest.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardQuestObjectiveBase`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/).[`id`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/#id)

***

### kind

[Section titled “kind”](#kind)

> **kind**: `"defeat-actor"`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:77](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L77)

Objective discriminator.

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:35](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L35)

Optional display label.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardQuestObjectiveBase`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/).[`label`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/#label)

***

### targetActor

[Section titled “targetActor”](#targetactor)

> **targetActor**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:79](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L79)

Target actor id.

# GameboardQuestObjectiveBase

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:31](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L31)

Shared fields for every quest objective.

## Extended by

[Section titled “Extended by”](#extended-by)

* [`ReachTileQuestObjective`](/declarative-hex-worlds/reference/traits/interfaces/reachtilequestobjective/)
* [`ReachActorQuestObjective`](/declarative-hex-worlds/reference/traits/interfaces/reachactorquestobjective/)
* [`InteractActorQuestObjective`](/declarative-hex-worlds/reference/traits/interfaces/interactactorquestobjective/)
* [`DefeatActorQuestObjective`](/declarative-hex-worlds/reference/traits/interfaces/defeatactorquestobjective/)
* [`CollisionQuestObjective`](/declarative-hex-worlds/reference/traits/interfaces/collisionquestobjective/)

## Properties

[Section titled “Properties”](#properties)

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L33)

Stable objective id within the quest.

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:35](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L35)

Optional display label.

# GameboardQuestObjectiveProgress

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:105](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L105)

Runtime progress for one quest objective.

## Properties

[Section titled “Properties”](#properties)

### completedAtStep?

[Section titled “completedAtStep?”](#completedatstep)

> `optional` **completedAtStep?**: `number`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:113](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L113)

Simulation/system step when completion or blocking occurred.

***

### detail

[Section titled “detail”](#detail)

> **detail**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:111](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L111)

Human-readable progress detail.

***

### objectiveId

[Section titled “objectiveId”](#objectiveid)

> **objectiveId**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:107](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L107)

Objective id.

***

### status

[Section titled “status”](#status)

> **status**: [`GameboardQuestObjectiveStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestobjectivestatus/)

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:109](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L109)

Objective status.

# InteractActorQuestObjective

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:63](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L63)

Objective completed when an actor interacts with another actor.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardQuestObjectiveBase`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/)

## Properties

[Section titled “Properties”](#properties)

### actor

[Section titled “actor”](#actor)

> **actor**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:67](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L67)

Source actor id.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L33)

Stable objective id within the quest.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardQuestObjectiveBase`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/).[`id`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/#id)

***

### kind

[Section titled “kind”](#kind)

> **kind**: `"interact-actor"`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L65)

Objective discriminator.

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:35](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L35)

Optional display label.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardQuestObjectiveBase`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/).[`label`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/#label)

***

### maxDistance?

[Section titled “maxDistance?”](#maxdistance)

> `optional` **maxDistance?**: `number`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:71](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L71)

Maximum accepted interaction distance.

***

### targetActor

[Section titled “targetActor”](#targetactor)

> **targetActor**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:69](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L69)

Target actor id.

# ReachActorQuestObjective

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:51](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L51)

Objective completed when an actor reaches another actor.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardQuestObjectiveBase`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/)

## Properties

[Section titled “Properties”](#properties)

### actor

[Section titled “actor”](#actor)

> **actor**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:55](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L55)

Source actor id.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L33)

Stable objective id within the quest.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardQuestObjectiveBase`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/).[`id`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/#id)

***

### kind

[Section titled “kind”](#kind)

> **kind**: `"reach-actor"`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:53](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L53)

Objective discriminator.

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:35](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L35)

Optional display label.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardQuestObjectiveBase`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/).[`label`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/#label)

***

### maxDistance?

[Section titled “maxDistance?”](#maxdistance)

> `optional` **maxDistance?**: `number`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:59](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L59)

Maximum accepted distance from the target actor.

***

### targetActor

[Section titled “targetActor”](#targetactor)

> **targetActor**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:57](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L57)

Target actor id.

# ReachTileQuestObjective

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:39](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L39)

Objective completed when an actor reaches a tile.

## Extends

[Section titled “Extends”](#extends)

* [`GameboardQuestObjectiveBase`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/)

## Properties

[Section titled “Properties”](#properties)

### actor

[Section titled “actor”](#actor)

> **actor**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:43](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L43)

Source actor id.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L33)

Stable objective id within the quest.

#### Inherited from

[Section titled “Inherited from”](#inherited-from)

[`GameboardQuestObjectiveBase`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/).[`id`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/#id)

***

### kind

[Section titled “kind”](#kind)

> **kind**: `"reach-tile"`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:41](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L41)

Objective discriminator.

***

### label?

[Section titled “label?”](#label)

> `optional` **label?**: `string`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:35](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L35)

Optional display label.

#### Inherited from

[Section titled “Inherited from”](#inherited-from-1)

[`GameboardQuestObjectiveBase`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/).[`label`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectivebase/#label)

***

### maxDistance?

[Section titled “maxDistance?”](#maxdistance)

> `optional` **maxDistance?**: `number`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:47](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L47)

Maximum accepted distance from the target tile.

***

### tile

[Section titled “tile”](#tile)

> **tile**: `string` | [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/)

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L45)

Target tile coordinates or tile key.

# BuiltInGameboardMovementProfileId

> **BuiltInGameboardMovementProfileId** = `"ground"` | `"worker"` | `"cavalry"` | `"ship"` | `"flying"`

Defined in: [packages/declarative-hex-worlds/src/traits/movement.ts:10](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/movement.ts#L10)

Built-in movement profile ids for common medieval board actors.

# GameboardActorKind

> **GameboardActorKind** = `"player"` | `"npc"` | `"enemy"` | `"prop"` | `"unit"` | `"neutral"` | `string` & `object`

Defined in: [packages/declarative-hex-worlds/src/traits/actors.ts:16](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/actors.ts#L16)

Actor role used by collision, targeting, commands, and SimpleRPG fixtures.

# GameboardActorMetadataValue

> **GameboardActorMetadataValue** = `string` | `number` | `boolean` | `null`

Defined in: [packages/declarative-hex-worlds/src/traits/actors.ts:26](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/actors.ts#L26)

Serializable actor metadata value mirrored into Koota state.

# GameboardMovementProfileId

> **GameboardMovementProfileId** = [`BuiltInGameboardMovementProfileId`](/declarative-hex-worlds/reference/traits/type-aliases/builtingameboardmovementprofileid/) | `string` & `object`

Defined in: [packages/declarative-hex-worlds/src/traits/movement.ts:13](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/movement.ts#L13)

Movement profile id accepted by movement helpers (built-in or custom string).

# GameboardMovementStatus

> **GameboardMovementStatus** = `"idle"` | `"ready"` | `"moving"` | `"completed"` | `"blocked"` | `"out-of-range"`

Defined in: [packages/declarative-hex-worlds/src/traits/movement.ts:16](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/movement.ts#L16)

Runtime movement path status for a movement agent.

# GameboardPatrolStatus

> **GameboardPatrolStatus** = `"idle"` | `"waiting"` | `"requested"` | `"moving"` | `"completed"` | `"blocked"` | `"paused"`

Defined in: [packages/declarative-hex-worlds/src/traits/patrol.ts:10](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/patrol.ts#L10)

Runtime patrol status for a patrol agent.

# GameboardQuestCollisionExpectation

> **GameboardQuestCollisionExpectation** = `"can-enter"` | `"blocked"` | `"hostile"` | `"interactive"` | `"prop"`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:21](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L21)

Collision expectation supported by collision quest objectives.

# GameboardQuestMetadataValue

> **GameboardQuestMetadataValue** = `string` | `number` | `boolean` | `null`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:28](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L28)

Serializable quest metadata value.

# GameboardQuestObjective

> **GameboardQuestObjective** = [`ReachTileQuestObjective`](/declarative-hex-worlds/reference/traits/interfaces/reachtilequestobjective/) | [`ReachActorQuestObjective`](/declarative-hex-worlds/reference/traits/interfaces/reachactorquestobjective/) | [`InteractActorQuestObjective`](/declarative-hex-worlds/reference/traits/interfaces/interactactorquestobjective/) | [`DefeatActorQuestObjective`](/declarative-hex-worlds/reference/traits/interfaces/defeatactorquestobjective/) | [`CollisionQuestObjective`](/declarative-hex-worlds/reference/traits/interfaces/collisionquestobjective/)

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:97](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L97)

Quest objective union.

# GameboardQuestObjectiveStatus

> **GameboardQuestObjectiveStatus** = `"pending"` | `"completed"` | `"blocked"`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:19](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L19)

Runtime quest objective status.

# GameboardQuestStatus

> **GameboardQuestStatus** = `"pending"` | `"active"` | `"completed"` | `"blocked"`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:17](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L17)

Runtime quest lifecycle status.

# AdjacentTo

> `const` **AdjacentTo**: `Relation`<`Trait`<{ `edge`: `number`; }>>

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:223](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L223)

Directional neighbor relation between adjacent axial hex tiles.

# GAMEBOARD_QUEST_SCHEMA_VERSION

> `const` **GAMEBOARD\_QUEST\_SCHEMA\_VERSION**: `"1.0.0"` = `'1.0.0'`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:14](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L14)

Schema version written to quest trait state.

# GameboardActor

> `const` **GameboardActor**: `Trait`<{ `actorId`: `string`; `blocksMovement`: `boolean`; `faction`: `string` | `undefined`; `hostile`: `boolean`; `interactive`: `boolean`; `kind`: [`GameboardActorKind`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactorkind/); `metadata`: () => `Record`<`string`, [`GameboardActorMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardactormetadatavalue/)>; `tags`: () => `string`\[]; `team`: `string` | `undefined`; }>

Defined in: [packages/declarative-hex-worlds/src/traits/actors.ts:29](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/actors.ts#L29)

Actor trait attached to placement entities that participate in gameplay.

# GameboardPatrolAgent

> `const` **GameboardPatrolAgent**: `Trait`<{ `active`: `boolean`; `currentWaypointIndex`: `number`; `loop`: `boolean`; `pauseTicks`: `number`; `roundsCompleted`: `number`; `routeId`: `string`; `segmentCosts`: () => `number`\[]; `targetWaypointIndex`: `number`; `waitTicksRemaining`: `number`; `waypointKeys`: () => `string`\[]; }>

Defined in: [packages/declarative-hex-worlds/src/traits/patrol.ts:20](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/patrol.ts#L20)

Patrol agent trait storing route progress and wait state.

# GameboardPatrolState

> `const` **GameboardPatrolState**: `Trait`<{ `lastPathKeys`: () => `string`\[]; `reason`: `string` | `undefined`; `status`: [`GameboardPatrolStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardpatrolstatus/); `targetKey`: `string`; }>

Defined in: [packages/declarative-hex-worlds/src/traits/patrol.ts:44](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/patrol.ts#L44)

Patrol state trait exposed for systems and UIs.

# GameboardQuest

> `const` **GameboardQuest**: `Trait`<{ `activeObjectiveIndex`: `number`; `metadata`: () => `Record`<`string`, [`GameboardQuestMetadataValue`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestmetadatavalue/)>; `objectives`: () => [`GameboardQuestObjective`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardquestobjective/)\[]; `progress`: () => [`GameboardQuestObjectiveProgress`](/declarative-hex-worlds/reference/traits/interfaces/gameboardquestobjectiveprogress/)\[]; `questId`: `string`; `schemaVersion`: `string`; `status`: [`GameboardQuestStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardqueststatus/); `title`: `string`; }>

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:117](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L117)

Quest trait storing definition, progress, active objective, and metadata.

# GameboardState

> `const` **GameboardState**: `Trait`<{ `placementCount`: `number`; `schemaVersion`: `string`; `seed`: `string`; `shape`: () => [`GameboardShape`](/declarative-hex-worlds/reference/types/type-aliases/gameboardshape/); `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileCount`: `number`; }>

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:31](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L31)

Board-level Koota trait with the deterministic plan metadata currently loaded into a world.

# HexTileState

> `const` **HexTileState**: `Trait`<{ `baseAssetId`: `string`; `coastEdges`: `number`; `coastWaterless`: `boolean`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `key`: `string`; `riverCrossing`: `"A"` | `"B"` | `undefined`; `riverCurvy`: `boolean`; `riverEdges`: `number`; `riverWaterless`: `boolean`; `roadEdges`: `number`; `roadSlope`: `"high"` | `"low"` | `undefined`; `supportAssetId`: `string`; `tags`: () => `string`\[]; `terrain`: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/); `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; }>

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:49](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L49)

Full tile trait used for serialization, rendering, and coarse tile queries.

# IsActiveGameboardQuest

> `const` **IsActiveGameboardQuest**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:139](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L139)

Marker trait for active quest entities.

# IsBlockedGameboardQuest

> `const` **IsBlockedGameboardQuest**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:143](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L143)

Marker trait for blocked quest entities.

# IsBlockingActor

> `const` **IsBlockingActor**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/actors.ts:65](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/actors.ts#L65)

Marker trait for movement-blocking actors.

# IsCoastPlacement

> `const` **IsCoastPlacement**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:191](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L191)

Marker trait for coast placements.

# IsCompletedGameboardQuest

> `const` **IsCompletedGameboardQuest**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:141](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L141)

Marker trait for completed quest entities.

# IsDecorationPlacement

> `const` **IsDecorationPlacement**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:193](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L193)

Marker trait for decorative placements.

# IsEnemyActor

> `const` **IsEnemyActor**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/actors.ts:57](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/actors.ts#L57)

Marker trait for enemy actors.

# IsGameboardActor

> `const` **IsGameboardActor**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/actors.ts:51](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/actors.ts#L51)

Marker trait for all gameplay actors.

# IsGameboardPatrolAgent

> `const` **IsGameboardPatrolAgent**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/patrol.ts:56](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/patrol.ts#L56)

Marker trait for patrol agents.

# IsGameboardPlacement

> `const` **IsGameboardPlacement**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:183](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L183)

Marker trait for all board placement entities.

# IsGameboardQuest

> `const` **IsGameboardQuest**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/quests.ts:137](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/quests.ts#L137)

Marker trait for quest entities.

# IsGameboardTile

> `const` **IsGameboardTile**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:181](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L181)

Marker trait for board tile entities.

# IsHarborPlacement

> `const` **IsHarborPlacement**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:201](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L201)

Marker trait for harbor-capable structure or prop placements.

# IsHostileActor

> `const` **IsHostileActor**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/actors.ts:61](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/actors.ts#L61)

Marker trait for hostile actors.

# IsInteractiveActor

> `const` **IsInteractiveActor**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/actors.ts:63](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/actors.ts#L63)

Marker trait for interactive actors.

# IsMoving

> `const` **IsMoving**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/movement.ts:55](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/movement.ts#L55)

Marker trait for placements with active movement.

# IsNpcActor

> `const` **IsNpcActor**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/actors.ts:55](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/actors.ts#L55)

Marker trait for NPC actors.

# IsPlayerActor

> `const` **IsPlayerActor**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/actors.ts:53](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/actors.ts#L53)

Marker trait for player actors.

# IsPropActor

> `const` **IsPropActor**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/actors.ts:59](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/actors.ts#L59)

Marker trait for prop actors.

# IsPropPlacement

> `const` **IsPropPlacement**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:199](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L199)

Marker trait for prop placements.

# IsRiverPlacement

> `const` **IsRiverPlacement**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:189](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L189)

Marker trait for river placements.

# IsRoadPlacement

> `const` **IsRoadPlacement**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:187](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L187)

Marker trait for road placements.

# IsStackedTerrain

> `const` **IsStackedTerrain**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:203](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L203)

Marker trait for elevated or explicitly stacked terrain placements.

# IsStructurePlacement

> `const` **IsStructurePlacement**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:195](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L195)

Marker trait for structure placements.

# IsTerrainPlacement

> `const` **IsTerrainPlacement**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:185](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L185)

Marker trait for terrain and transition placements.

# IsUnitPlacement

> `const` **IsUnitPlacement**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:197](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L197)

Marker trait for unit placements.

# MovementAgent

> `const` **MovementAgent**: `Trait`<{ `movementBudget`: `number`; `profileId`: [`GameboardMovementProfileId`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementprofileid/); `remainingMovement`: `number`; }>

Defined in: [packages/declarative-hex-worlds/src/traits/movement.ts:25](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/movement.ts#L25)

Movement agent trait attached to placement entities that can move.

# MovementPathState

> `const` **MovementPathState**: `Trait`<{ `cost`: `number`; `destinationKey`: `string`; `nextIndex`: `number`; `pathKeys`: () => `string`\[]; `reason`: `string` | `undefined`; `spentCost`: `number`; `status`: [`GameboardMovementStatus`](/declarative-hex-worlds/reference/traits/type-aliases/gameboardmovementstatus/); `visited`: `number`; }>

Defined in: [packages/declarative-hex-worlds/src/traits/movement.ts:35](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/movement.ts#L35)

Runtime path state for a movement agent.

# PlacementOccupiesTile

> `const` **PlacementOccupiesTile**: `Relation`<`Trait`<{ `blocksMovement`: `boolean`; `footprintIndex`: `number`; `occupancyGroup`: `string`; `originTileKey`: `string`; }>>

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:210](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L210)

Non-exclusive relation from a placement to every tile in its footprint.

# PlacementOnTile

> `const` **PlacementOnTile**: `Relation`<`Trait`<`Record`<`string`, `never`>>>

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:208](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L208)

Exclusive relation from a placement to its origin tile.

# PlacementState

> `const` **PlacementState**: `Trait`<{ `assetId`: `string`; `coordinates`: () => [`HexCoordinates`](/declarative-hex-worlds/reference/types/interfaces/hexcoordinates/); `elevation`: `number`; `elevationOffset`: `number`; `id`: `string`; `kind`: [`GameboardPlacementKind`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementkind/); `layer`: [`GameboardPlacementLayer`](/declarative-hex-worlds/reference/index/type-aliases/gameboardplacementlayer/); `metadata`: () => `Record`<`string`, `string` | `number` | `boolean` | `null`>; `order`: `number`; `position`: () => [`WorldPosition`](/declarative-hex-worlds/reference/types/interfaces/worldposition/); `requiresExtra`: `boolean`; `rotationRadians`: `number`; `rotationSteps`: `number`; `scale`: `number`; `stackIndex`: `number` | `undefined`; `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; `tileKey`: `string`; }>

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:143](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L143)

Runtime placement trait for terrain overlays, structures, units, props, and externally registered pieces.

# RequiresExtraAsset

> `const` **RequiresExtraAsset**: `TagTrait`

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:205](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L205)

Marker trait for placements whose assets are supplied by local EXTRA ingest.

# TileConnectivity

> `const` **TileConnectivity**: `Trait`<{ `coastEdges`: `number`; `coastWaterless`: `boolean`; `riverCrossing`: `"A"` | `"B"` | `undefined`; `riverCurvy`: `boolean`; `riverEdges`: `number`; `riverWaterless`: `boolean`; `roadEdges`: `number`; `roadSlope`: `"high"` | `"low"` | `undefined`; }>

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:111](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L111)

Decomposed edge connectivity trait used by roads, rivers, coasts, and pathing.

# TileCoordinates

> `const` **TileCoordinates**: `Trait`<{ `key`: `string`; `q`: `number`; `r`: `number`; }>

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:85](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L85)

Decomposed coordinate trait for systems that only need tile lookup data.

# TileElevation

> `const` **TileElevation**: `Trait`<{ `baseAssetId`: `string`; `elevation`: `number`; `supportAssetId`: `string`; }>

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:101](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L101)

Decomposed elevation trait for stacking, movement, and rendering systems.

# TileRenderState

> `const` **TileRenderState**: `Trait`<{ `textureSet`: `"default"` | `"fall"` | `"summer"` | `"winter"`; }>

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:131](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L131)

Decomposed render trait for systems that switch seasonal texture sets.

# TileTagList

> `const` **TileTagList**: `Trait`<() => `string`\[]>

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:137](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L137)

Decomposed tag list trait used by selectors, recipes, and seeded generation.

# TileTerrain

> `const` **TileTerrain**: `Trait`<{ `terrain`: [`GameboardTerrain`](/declarative-hex-worlds/reference/index/type-aliases/gameboardterrain/); }>

Defined in: [packages/declarative-hex-worlds/src/traits/board.ts:95](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/traits/board.ts#L95)

Decomposed terrain trait for biome and placement-rule systems.

# brandActorId

> **brandActorId**(`value`): [`ActorId`](/declarative-hex-worlds/reference/types/type-aliases/actorid/)

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:64](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L64)

Brand a string as an [ActorId](/declarative-hex-worlds/reference/types/type-aliases/actorid/). Caller must validate.

## Parameters

[Section titled “Parameters”](#parameters)

### value

[Section titled “value”](#value)

`string`

## Returns

[Section titled “Returns”](#returns)

[`ActorId`](/declarative-hex-worlds/reference/types/type-aliases/actorid/)

# brandAssetId

> **brandAssetId**(`value`): [`AssetId`](/declarative-hex-worlds/reference/types/type-aliases/assetid/)

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:96](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L96)

Brand a string as an [AssetId](/declarative-hex-worlds/reference/types/type-aliases/assetid/). Caller must validate.

## Parameters

[Section titled “Parameters”](#parameters)

### value

[Section titled “value”](#value)

`string`

## Returns

[Section titled “Returns”](#returns)

[`AssetId`](/declarative-hex-worlds/reference/types/type-aliases/assetid/)

# brandHexKey

> **brandHexKey**(`value`): [`HexKey`](/declarative-hex-worlds/reference/types/type-aliases/hexkey/)

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:60](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L60)

Brand a string as a [HexKey](/declarative-hex-worlds/reference/types/type-aliases/hexkey/). Caller must validate.

## Parameters

[Section titled “Parameters”](#parameters)

### value

[Section titled “value”](#value)

`string`

## Returns

[Section titled “Returns”](#returns)

[`HexKey`](/declarative-hex-worlds/reference/types/type-aliases/hexkey/)

# brandObjectiveId

> **brandObjectiveId**(`value`): [`ObjectiveId`](/declarative-hex-worlds/reference/types/type-aliases/objectiveid/)

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:88](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L88)

Brand a string as an [ObjectiveId](/declarative-hex-worlds/reference/types/type-aliases/objectiveid/). Caller must validate.

## Parameters

[Section titled “Parameters”](#parameters)

### value

[Section titled “value”](#value)

`string`

## Returns

[Section titled “Returns”](#returns)

[`ObjectiveId`](/declarative-hex-worlds/reference/types/type-aliases/objectiveid/)

# brandPatrolRouteId

> **brandPatrolRouteId**(`value`): [`PatrolRouteId`](/declarative-hex-worlds/reference/types/type-aliases/patrolrouteid/)

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:92](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L92)

Brand a string as a [PatrolRouteId](/declarative-hex-worlds/reference/types/type-aliases/patrolrouteid/). Caller must validate.

## Parameters

[Section titled “Parameters”](#parameters)

### value

[Section titled “value”](#value)

`string`

## Returns

[Section titled “Returns”](#returns)

[`PatrolRouteId`](/declarative-hex-worlds/reference/types/type-aliases/patrolrouteid/)

# brandPieceId

> **brandPieceId**(`value`): [`PieceId`](/declarative-hex-worlds/reference/types/type-aliases/pieceid/)

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:72](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L72)

Brand a string as a [PieceId](/declarative-hex-worlds/reference/types/type-aliases/pieceid/). Caller must validate.

## Parameters

[Section titled “Parameters”](#parameters)

### value

[Section titled “value”](#value)

`string`

## Returns

[Section titled “Returns”](#returns)

[`PieceId`](/declarative-hex-worlds/reference/types/type-aliases/pieceid/)

# brandPlacementId

> **brandPlacementId**(`value`): [`PlacementId`](/declarative-hex-worlds/reference/types/type-aliases/placementid/)

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:76](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L76)

Brand a string as a [PlacementId](/declarative-hex-worlds/reference/types/type-aliases/placementid/). Caller must validate.

## Parameters

[Section titled “Parameters”](#parameters)

### value

[Section titled “value”](#value)

`string`

## Returns

[Section titled “Returns”](#returns)

[`PlacementId`](/declarative-hex-worlds/reference/types/type-aliases/placementid/)

# brandQuestId

> **brandQuestId**(`value`): [`QuestId`](/declarative-hex-worlds/reference/types/type-aliases/questid/)

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:84](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L84)

Brand a string as a [QuestId](/declarative-hex-worlds/reference/types/type-aliases/questid/). Caller must validate.

## Parameters

[Section titled “Parameters”](#parameters)

### value

[Section titled “value”](#value)

`string`

## Returns

[Section titled “Returns”](#returns)

[`QuestId`](/declarative-hex-worlds/reference/types/type-aliases/questid/)

# brandScenarioId

> **brandScenarioId**(`value`): [`ScenarioId`](/declarative-hex-worlds/reference/types/type-aliases/scenarioid/)

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:80](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L80)

Brand a string as a [ScenarioId](/declarative-hex-worlds/reference/types/type-aliases/scenarioid/). Caller must validate.

## Parameters

[Section titled “Parameters”](#parameters)

### value

[Section titled “value”](#value)

`string`

## Returns

[Section titled “Returns”](#returns)

[`ScenarioId`](/declarative-hex-worlds/reference/types/type-aliases/scenarioid/)

# brandTileId

> **brandTileId**(`value`): [`TileId`](/declarative-hex-worlds/reference/types/type-aliases/tileid/)

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:68](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L68)

Brand a string as a [TileId](/declarative-hex-worlds/reference/types/type-aliases/tileid/). Caller must validate.

## Parameters

[Section titled “Parameters”](#parameters)

### value

[Section titled “value”](#value)

`string`

## Returns

[Section titled “Returns”](#returns)

[`TileId`](/declarative-hex-worlds/reference/types/type-aliases/tileid/)

# AssetBounds

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:118](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L118)

Axis-aligned model bounds extracted from GLTF accessor min/max values.

## Properties

[Section titled “Properties”](#properties)

### max

[Section titled “max”](#max)

> **max**: readonly \[`number`, `number`, `number`]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:122](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L122)

Maximum x/y/z coordinate in model-local units.

***

### min

[Section titled “min”](#min)

> **min**: readonly \[`number`, `number`, `number`]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:120](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L120)

Minimum x/y/z coordinate in model-local units.

***

### size

[Section titled “size”](#size)

> **size**: readonly \[`number`, `number`, `number`]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:124](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L124)

Width, height, and depth derived from `max - min`.

# HexagonGameboardShape

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:287](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L287)

Hexagonal board shape supported by grid, recipe, and seeded generation.

## Properties

[Section titled “Properties”](#properties)

### kind

[Section titled “kind”](#kind)

> **kind**: `"hexagon"`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:289](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L289)

Shape discriminator.

***

### radius

[Section titled “radius”](#radius)

> **radius**: `number`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:291](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L291)

Radius in rings around the origin.

# HexCoordinates

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:253](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L253)

Axial flat-top hex coordinate.

## Properties

[Section titled “Properties”](#properties)

### q

[Section titled “q”](#q)

> **q**: `number`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:255](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L255)

Axial q column.

***

### r

[Section titled “r”](#r)

> **r**: `number`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:257](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L257)

Axial r row.

# MedievalHexagonAsset

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:151](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L151)

One renderable GLTF asset with normalized taxonomy, paths, bounds, and material metadata.

## Properties

[Section titled “Properties”](#properties)

### bounds

[Section titled “bounds”](#bounds)

> **bounds**: [`AssetBounds`](/declarative-hex-worlds/reference/types/interfaces/assetbounds/)

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:179](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L179)

Extracted model bounds used by fit checks and camera framing.

***

### bufferPaths

[Section titled “bufferPaths”](#bufferpaths)

> **bufferPaths**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:173](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L173)

Package-relative buffer paths referenced by the GLTF.

***

### category

[Section titled “category”](#category)

> **category**: `"tiles"` | `"buildings"` | `"decoration"` | `"units"`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:157](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L157)

Top-level KayKit category.

***

### edition

[Section titled “edition”](#edition)

> **edition**: `"free"` | `"extra"`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:155](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L155)

Source edition that owns this asset.

***

### faction?

[Section titled “faction?”](#faction)

> `optional` **faction?**: `"blue"` | `"green"` | `"red"` | `"yellow"`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:163](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L163)

Faction color when the asset is faction-specific.

***

### family

[Section titled “family”](#family)

> **family**: `string`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:161](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L161)

Variant family with faction/style suffixes removed where applicable.

***

### fileSizeBytes

[Section titled “fileSizeBytes”](#filesizebytes)

> **fileSizeBytes**: `number`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:181](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L181)

Size of the source GLTF JSON file in bytes.

***

### id

[Section titled “id”](#id)

> **id**: `string`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:153](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L153)

Stable asset id, normally the GLTF file name without extension.

***

### materialSlots

[Section titled “materialSlots”](#materialslots)

> **materialSlots**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:177](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L177)

Material names discovered from the GLTF.

***

### modelPath

[Section titled “modelPath”](#modelpath)

> **modelPath**: `string`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:169](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L169)

Package-relative or consumer-resolved model path.

***

### sourcePath

[Section titled “sourcePath”](#sourcepath)

> **sourcePath**: `string`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:171](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L171)

Source-relative path inside the ingested GLTF tree.

***

### subcategory

[Section titled “subcategory”](#subcategory)

> **subcategory**: `string`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:159](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L159)

Category-specific folder segment, such as `roads`, `blue`, or `nature`.

***

### texturePaths

[Section titled “texturePaths”](#texturepaths)

> **texturePaths**: readonly `string`\[]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:175](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L175)

Package-relative texture paths referenced by the GLTF.

***

### textureSet

[Section titled “textureSet”](#textureset)

> **textureSet**: `"default"` | `"fall"` | `"summer"` | `"winter"`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:167](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L167)

Texture palette expected by the asset.

***

### unitStyle?

[Section titled “unitStyle?”](#unitstyle)

> `optional` **unitStyle?**: `"neutral"` | `"accent"` | `"full"`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:165](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L165)

Unit recolor style when the asset belongs to `units`.

# MedievalHexagonManifest

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:199](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L199)

Complete normalized asset manifest for one source edition.

## Properties

[Section titled “Properties”](#properties)

### assets

[Section titled “assets”](#assets)

> **assets**: readonly [`MedievalHexagonAsset`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonasset/)\[]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:211](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L211)

Ordered asset records.

***

### assetsById

[Section titled “assetsById”](#assetsbyid)

> **assetsById**: `Readonly`<`Record`<`string`, [`MedievalHexagonAsset`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonasset/)>>

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:213](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L213)

Asset lookup by stable id.

***

### counts

[Section titled “counts”](#counts)

> **counts**: [`MedievalHexagonManifestCounts`](/declarative-hex-worlds/reference/types/interfaces/medievalhexagonmanifestcounts/)

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:215](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L215)

Derived counts for audit and UI summaries.

***

### edition

[Section titled “edition”](#edition)

> **edition**: `"free"` | `"extra"`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:205](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L205)

Source edition represented by this manifest.

***

### generatedAt

[Section titled “generatedAt”](#generatedat)

> **generatedAt**: `string`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:203](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L203)

Stable generation timestamp used by reproducible package assets.

***

### schemaVersion

[Section titled “schemaVersion”](#schemaversion)

> **schemaVersion**: `"1.0.0"`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:201](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L201)

Manifest schema version.

***

### sourcePack

[Section titled “sourcePack”](#sourcepack)

> **sourcePack**: [`SourcePackInfo`](/declarative-hex-worlds/reference/types/interfaces/sourcepackinfo/)

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:207](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L207)

Attribution and source-pack provenance.

***

### textureSets

[Section titled “textureSets”](#texturesets)

> **textureSets**: readonly (`"default"` | `"fall"` | `"summer"` | `"winter"`)\[]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:209](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L209)

Texture palettes present in this edition.

# MedievalHexagonManifestCounts

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:187](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L187)

Manifest asset counts grouped for audit, package validation, and docs.

## Properties

[Section titled “Properties”](#properties)

### byCategory

[Section titled “byCategory”](#bycategory)

> **byCategory**: `Record`<`string`, `number`>

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:191](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L191)

Counts keyed by top-level category.

***

### bySubcategory

[Section titled “bySubcategory”](#bysubcategory)

> **bySubcategory**: `Record`<`string`, `number`>

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:193](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L193)

Counts keyed as `category/subcategory`.

***

### total

[Section titled “total”](#total)

> **total**: `number`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:189](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L189)

Total number of GLTF model records.

# RectangleGameboardShape

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:275](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L275)

Rectangular board shape supported by grid, recipe, and seeded generation.

## Properties

[Section titled “Properties”](#properties)

### height

[Section titled “height”](#height)

> **height**: `number`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:281](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L281)

Number of rows.

***

### kind

[Section titled “kind”](#kind)

> **kind**: `"rectangle"`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:277](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L277)

Shape discriminator.

***

### width

[Section titled “width”](#width)

> **width**: `number`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:279](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L279)

Number of columns.

# SourcePackInfo

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:130](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L130)

Attribution and provenance for one KayKit source pack edition.

## Properties

[Section titled “Properties”](#properties)

### creator

[Section titled “creator”](#creator)

> **creator**: `string`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:138](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L138)

Asset creator credited by NOTICE.md and generated manifests.

***

### edition

[Section titled “edition”](#edition)

> **edition**: `"free"` | `"extra"`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:136](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L136)

Edition represented by the manifest.

***

### license

[Section titled “license”](#license)

> **license**: `"CC0-1.0"`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:140](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L140)

SPDX-style license identifier for KayKit assets.

***

### licenseUrl

[Section titled “licenseUrl”](#licenseurl)

> **licenseUrl**: `string`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:142](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L142)

Canonical license URL.

***

### name

[Section titled “name”](#name)

> **name**: `string`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:132](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L132)

Human-readable pack name.

***

### sourceRootName

[Section titled “sourceRootName”](#sourcerootname)

> **sourceRootName**: `string`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:144](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L144)

Local source directory name used during ingest.

***

### version

[Section titled “version”](#version)

> **version**: `string`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:134](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L134)

Source pack version.

# VariantSelection

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:233](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L233)

Result of mapping an arbitrary guide edge mask to a canonical asset and rotation.

## Properties

[Section titled “Properties”](#properties)

### assetId

[Section titled “assetId”](#assetid)

> **assetId**: `string`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:239](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L239)

Asset id that should be rendered.

***

### canonicalMask

[Section titled “canonicalMask”](#canonicalmask)

> **canonicalMask**: `number`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:243](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L243)

Canonical edge bitmask represented by the selected asset.

***

### family

[Section titled “family”](#family)

> **family**: `"coast"` | `"road"` | `"river"`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:235](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L235)

Variant family being selected.

***

### inputMask

[Section titled “inputMask”](#inputmask)

> **inputMask**: `number`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:241](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L241)

User-requested edge bitmask before canonicalization.

***

### label

[Section titled “label”](#label)

> **label**: `string`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:237](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L237)

Guide label such as `A`, `B`, or `crossing_A`.

***

### rotationRadians

[Section titled “rotationRadians”](#rotationradians)

> **rotationRadians**: `number`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:247](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L247)

Rotation in radians for renderers.

***

### rotationSteps

[Section titled “rotationSteps”](#rotationsteps)

> **rotationSteps**: `number`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:245](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L245)

Clockwise 60-degree rotation steps to apply.

# WorldPosition

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:263](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L263)

Three-dimensional world-space position used by gameboard plans and renderers.

## Properties

[Section titled “Properties”](#properties)

### x

[Section titled “x”](#x)

> **x**: `number`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:265](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L265)

Horizontal x coordinate.

***

### y

[Section titled “y”](#y)

> **y**: `number`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:267](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L267)

Vertical y coordinate.

***

### z

[Section titled “z”](#z)

> **z**: `number`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:269](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L269)

Horizontal z coordinate.

# ActorId

> **ActorId** = [`Branded`](/declarative-hex-worlds/reference/types/type-aliases/branded/)<`"ActorId"`>

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:33](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L33)

Stable identifier for an authored actor (NPC, player, prop, projectile).

# AssetCategory

> **AssetCategory** = *typeof* [`ASSET_CATEGORIES`](/declarative-hex-worlds/reference/types/variables/asset_categories/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:82](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L82)

Top-level source-pack category for a manifest asset.

# AssetId

> **AssetId** = [`Branded`](/declarative-hex-worlds/reference/types/type-aliases/branded/)<`"AssetId"`>

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:57](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L57)

Stable identifier for an asset entry in a manifest.

# Branded

> **Branded**<`TBrand`> = `string` & `object`

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:24](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L24)

Internal helper: a phantom-typed string distinguishable by its brand tag.

Consumers should reference the exported branded types directly (`HexKey`, `ActorId`, …), not this generic.

## Type Declaration

[Section titled “Type Declaration”](#type-declaration)

### \[\_\_\_brand]

[Section titled “\[\_\_\_brand\]”](#___brand)

> `readonly` **\[\_\_\_brand]**: `TBrand`

Phantom marker that gives this string nominal identity at the type level.

## Type Parameters

[Section titled “Type Parameters”](#type-parameters)

### TBrand

[Section titled “TBrand”](#tbrand)

`TBrand` *extends* `string`

# Faction

> **Faction** = *typeof* [`FACTIONS`](/declarative-hex-worlds/reference/types/variables/factions/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:92](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L92)

KayKit faction color identifier.

# GameboardShape

> **GameboardShape** = [`RectangleGameboardShape`](/declarative-hex-worlds/reference/types/interfaces/rectanglegameboardshape/) | [`HexagonGameboardShape`](/declarative-hex-worlds/reference/types/interfaces/hexagongameboardshape/)

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:297](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L297)

Serializable board shape supported by grid, recipe, and seeded generation.

# HexEdgeIndex

> **HexEdgeIndex** = `0` | `1` | `2` | `3` | `4` | `5`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:222](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L222)

Clockwise flat-top hex edge index, starting from the library’s canonical edge zero.

# HexEdgeInput

> **HexEdgeInput** = [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/) | readonly [`HexEdgeIndex`](/declarative-hex-worlds/reference/types/type-aliases/hexedgeindex/)\[] | `number`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:227](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L227)

Edge input accepted by selector and rule helpers.

# HexKey

> **HexKey** = [`Branded`](/declarative-hex-worlds/reference/types/type-aliases/branded/)<`"HexKey"`>

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:30](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L30)

Stringified hex coordinate of the form `"q,r"` — e.g. `"3,-2"`.

# ObjectiveId

> **ObjectiveId** = [`Branded`](/declarative-hex-worlds/reference/types/type-aliases/branded/)<`"ObjectiveId"`>

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:51](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L51)

Stable identifier for a quest objective inside a quest.

# PackEdition

> **PackEdition** = *typeof* [`PACK_EDITIONS`](/declarative-hex-worlds/reference/types/variables/pack_editions/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:72](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L72)

Manifest edition. `free` assets are published with the package; `extra` assets are local-only and come from the ignored ingest source.

# PatrolRouteId

> **PatrolRouteId** = [`Branded`](/declarative-hex-worlds/reference/types/type-aliases/branded/)<`"PatrolRouteId"`>

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:54](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L54)

Stable identifier for a patrol route attached to one or more actors.

# PieceId

> **PieceId** = [`Branded`](/declarative-hex-worlds/reference/types/type-aliases/branded/)<`"PieceId"`>

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:39](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L39)

Stable identifier for a piece declaration in the registry.

# PlacementId

> **PlacementId** = [`Branded`](/declarative-hex-worlds/reference/types/type-aliases/branded/)<`"PlacementId"`>

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:42](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L42)

Stable identifier for a placement instance (a piece dropped onto a tile).

# QuestId

> **QuestId** = [`Branded`](/declarative-hex-worlds/reference/types/type-aliases/branded/)<`"QuestId"`>

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:48](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L48)

Stable identifier for a quest (with objectives) attached to a scenario.

# ScenarioId

> **ScenarioId** = [`Branded`](/declarative-hex-worlds/reference/types/type-aliases/branded/)<`"ScenarioId"`>

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L45)

Stable identifier for a scenario document.

# TextureSet

> **TextureSet** = *typeof* [`TEXTURE_SETS`](/declarative-hex-worlds/reference/types/variables/texture_sets/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:113](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L113)

Texture palette identifier. The FREE pack only ships `default`; EXTRA ingest can add fall, summer, and winter variants.

# TileId

> **TileId** = [`Branded`](/declarative-hex-worlds/reference/types/type-aliases/branded/)<`"TileId"`>

Defined in: [packages/declarative-hex-worlds/src/types/brands.ts:36](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/brands.ts#L36)

Stable identifier for a tile placement on the board grid.

# UnitStyle

> **UnitStyle** = *typeof* [`UNIT_STYLES`](/declarative-hex-worlds/reference/types/variables/unit_styles/)\[`number`]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:102](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L102)

Unit style taxonomy for neutral units and EXTRA faction recolors.

# ASSET_CATEGORIES

> `const` **ASSET\_CATEGORIES**: readonly \[`"tiles"`, `"buildings"`, `"decoration"`, `"units"`]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:77](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L77)

Top-level source-pack category used by KayKit’s GLTF folder structure.

# FACTIONS

> `const` **FACTIONS**: readonly \[`"blue"`, `"green"`, `"red"`, `"yellow"`]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:87](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L87)

Faction color variants used by KayKit buildings, flags, and units.

# GAMEBOARD_SCHEMA_VERSION

> `const` **GAMEBOARD\_SCHEMA\_VERSION**: `"1.0.0"` = `'1.0.0'`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:56](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L56)

Schema version written to generated gameboard plans.

Lives here (and not in `src/gameboard/`) so trait declarations under `src/traits/` can reference it without importing the gameboard module at runtime — which would re-enter the same dependency cycle that R2’s decomposition is meant to keep linear (`traits → types`, never `traits → gameboard`).

# HEX_WORLDS_SCHEMA_VERSION

> `const` **HEX\_WORLDS\_SCHEMA\_VERSION**: `"1.0.0"` = `'1.0.0'`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:45](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L45)

Current manifest schema emitted by the ingest CLI and bundled FREE manifest.

# KAYKIT_PACK_VERSION

> `const` **KAYKIT\_PACK\_VERSION**: `"1.0"` = `'1.0'`

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:61](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L61)

KayKit Medieval Hexagon pack version represented by this package.

# PACK_EDITIONS

> `const` **PACK\_EDITIONS**: readonly \[`"free"`, `"extra"`]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:66](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L66)

Asset editions understood by manifests and package helpers.

# TEXTURE_SETS

> `const` **TEXTURE\_SETS**: readonly \[`"default"`, `"fall"`, `"summer"`, `"winter"`]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:107](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L107)

Texture palettes exposed by the FREE and EXTRA source packs.

# UNIT_STYLES

> `const` **UNIT\_STYLES**: readonly \[`"neutral"`, `"accent"`, `"full"`]

Defined in: [packages/declarative-hex-worlds/src/types/index.ts:97](https://github.com/jbcom/declarative-hex-worlds/blob/e24756862d851d991ba07c68489d726a2b2ffd64/packages/declarative-hex-worlds/src/types/index.ts#L97)

KayKit EXTRA unit style variants.