@jgengine/core 0.17.0 → 0.18.1

package/dist/world/terrain.d.ts

@@ -203,9 +203,13 @@ export interface ResolvedTerrainDetailMaterial {
     tint: number;
 }
 /** A {@link TerrainDetailConfig} with every field resolved to a concrete value — the shape the shell's detail material consumes. */
-export type ResolvedTerrainDetail = Required<Omit<TerrainDetailConfig, "waterLevel" | "material">> & {
+export type ResolvedTerrainDetail = Required<Omit<TerrainDetailConfig, "waterLevel" | "material" | "sweeps">> & {
     waterLevel: number;
     material?: ResolvedTerrainDetailMaterial;
+    sweeps: {
+        dry: readonly [number, number, number];
+        wet: readonly [number, number, number];
+    };
 };
 /** Fill a `TerrainDetailConfig` with defaults; `waterLevel` falls back to the terrain's own water level.
  * @internal

package/dist/world/terrain.js

@@ -475,6 +475,7 @@ const DEFAULT_TERRAIN_DETAIL = {
     macroScale: 45,
     roughness: 0.9,
     strength: 1,
+    sweeps: { dry: [1.14, 1.05, 0.76], wet: [0.78, 1.0, 0.86] },
 };
 const DEFAULT_TERRAIN_MATERIAL_REPEAT = 4;
 const DEFAULT_TERRAIN_MATERIAL_STRENGTH = 1;
@@ -493,6 +494,10 @@ export function resolveTerrainDetail(config, terrainWaterLevel = 0) {
         macroScale: config.macroScale ?? DEFAULT_TERRAIN_DETAIL.macroScale,
         roughness: config.roughness ?? DEFAULT_TERRAIN_DETAIL.roughness,
         strength: clamp01(config.strength ?? DEFAULT_TERRAIN_DETAIL.strength),
+        sweeps: {
+            dry: config.sweeps?.dry ?? DEFAULT_TERRAIN_DETAIL.sweeps.dry,
+            wet: config.sweeps?.wet ?? DEFAULT_TERRAIN_DETAIL.sweeps.wet,
+        },
         waterLevel: config.waterLevel ?? terrainWaterLevel,
         ...(config.material === undefined
             ? {}

package/dist/world/territory.d.ts

@@ -0,0 +1,97 @@
+import type { GameRuntimeSnapshot } from "../runtime/snapshot.js";
+import type { Aabb } from "./geometry.js";
+/** Integer cell coordinates used for ownership on the ground plane. */
+export type TerritoryCell = {
+    x: number;
+    z: number;
+};
+/** Cell size, foreign-owner gap, growth price, currency and starter-grant policy. */
+export type TerritoryPolicy = {
+    gapCells?: number;
+    cellSize?: number;
+    chunkSize?: number;
+    currency?: string;
+    price?: (ownedCount: number) => number;
+    starterBlock?: number;
+    nowMs?: number;
+};
+/** Atomic claim outcome with the replacement snapshot and total charge. */
+export type TerritoryResult = {
+    ok: true;
+    snapshot: GameRuntimeSnapshot;
+    cost: number;
+} | {
+    ok: false;
+    reason: "territory.blocked" | "territory.unaffordable";
+};
+/** Read-only footprint quote or a blocked/insufficient-balance rejection. */
+export type TerritoryPlan = {
+    ok: true;
+    cells: TerritoryCell[];
+    cost: number;
+} | {
+    ok: false;
+    reason: "territory.blocked" | "territory.unaffordable";
+};
+/** Host-owned snapshot access used by the territory facade. */
+export interface TerritoryStorage {
+    get(): GameRuntimeSnapshot;
+    set(snapshot: GameRuntimeSnapshot): void;
+}
+/**
+ * Persisted chunk key containing one territory cell.
+ * @capability territory-cell-chunk Map ownership cells to persisted world chunks.
+ */
+export declare function territoryChunkKey(cell: TerritoryCell, policy?: TerritoryPolicy): string;
+/**
+ * Exact chunks needed to validate a footprint and its foreign-owner gap.
+ * @capability territory-read-scope Load the footprint and foreign-owner gap without scanning the world.
+ */
+export declare function territoryChunkKeys(cells: readonly TerritoryCell[], policy?: TerritoryPolicy): string[];
+/**
+ * Owner of a loaded cell; hosts load the target and gap neighborhood before evaluating claims.
+ * @capability territory-owner-query Read a loaded land cell owner for authoritative placement checks.
+ */
+export declare function territoryOwnerOf(snapshot: GameRuntimeSnapshot, cell: TerritoryCell, policy?: TerritoryPolicy): string | null;
+/**
+ * Cells touched by a placement, excluding cells that only touch its outer edge.
+ * @capability territory-footprint Resolve exactly the ownership cells touched by a placement footprint.
+ */
+export declare function territoryFootprintCells(bounds: Aabb, cellSize?: number): TerritoryCell[];
+/** Price and validate a footprint without mutating or charging; reuse for placement previews. */
+export declare function planFootprintClaims(snapshot: GameRuntimeSnapshot, userId: string, footprint: readonly TerritoryCell[], policy?: TerritoryPolicy): TerritoryPlan;
+/** Atomically buy every unowned footprint cell, leaving the input untouched on failure. */
+export declare function claimTerritory(snapshot: GameRuntimeSnapshot, userId: string, cells: readonly TerritoryCell[], policy?: TerritoryPolicy): TerritoryResult;
+/**
+ * Placement transaction: rejected object placement also rolls back territory and its charge.
+ * @capability territory-placement Purchase footprint cells atomically with object placement.
+ */
+export declare function placeWithTerritory(snapshot: GameRuntimeSnapshot, userId: string, bounds: Aabb, policy: TerritoryPolicy, place: (snapshot: GameRuntimeSnapshot) => {
+    ok: true;
+    snapshot: GameRuntimeSnapshot;
+} | {
+    ok: false;
+    reason: string;
+}): {
+    ok: true;
+    snapshot: GameRuntimeSnapshot;
+    cost: number;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Snapshot-backed territory facade with host-owned storage and live policy.
+ * @capability territory-ownership Claim, release and query land through host-owned snapshot storage.
+ */
+export declare function createTerritory(storage: TerritoryStorage, policy?: () => TerritoryPolicy): {
+    snapshot: () => GameRuntimeSnapshot;
+    restore: (snapshot: GameRuntimeSnapshot) => void;
+    ownerOf: (cell: TerritoryCell) => string | null;
+    canUse: (userId: string, cell: TerritoryCell) => boolean;
+    claim(userId: string, cells: readonly TerritoryCell[]): TerritoryResult;
+    release(userId: string, cell: TerritoryCell): boolean;
+    grantStarter(userId: string, center: TerritoryCell): TerritoryResult;
+};
+/** Snapshot-backed claim, release, owner and starter-grant operations. */
+export type Territory = ReturnType<typeof createTerritory>;

package/dist/world/territory.js

@@ -0,0 +1,182 @@
+import { chunkKeyAt, updateChunk } from "../runtime/worldChunks.js";
+function checked(policy) {
+    if (policy.nowMs !== undefined && !Number.isFinite(policy.nowMs))
+        throw new RangeError("Invalid territory timestamp");
+    const gapCells = policy.gapCells ?? 0, cellSize = policy.cellSize ?? 1, chunkSize = policy.chunkSize ?? 64;
+    if (!Number.isSafeInteger(gapCells) || gapCells < 0 || gapCells > 128 || !Number.isFinite(cellSize) || cellSize <= 0 || !Number.isFinite(chunkSize) || chunkSize <= 0)
+        throw new RangeError("Invalid territory policy");
+    return { gapCells, cellSize, chunkSize };
+}
+function key(cell) {
+    if (!Number.isSafeInteger(cell.x) || !Number.isSafeInteger(cell.z))
+        throw new RangeError("Invalid territory cell");
+    return `${cell.x},${cell.z}`;
+}
+/**
+ * Persisted chunk key containing one territory cell.
+ * @capability territory-cell-chunk Map ownership cells to persisted world chunks.
+ */
+export function territoryChunkKey(cell, policy = {}) {
+    key(cell);
+    const { cellSize, chunkSize } = checked(policy);
+    return chunkKeyAt([cell.x * cellSize, 0, cell.z * cellSize], chunkSize);
+}
+/**
+ * Exact chunks needed to validate a footprint and its foreign-owner gap.
+ * @capability territory-read-scope Load the footprint and foreign-owner gap without scanning the world.
+ */
+export function territoryChunkKeys(cells, policy = {}) {
+    const { gapCells } = checked(policy);
+    const chunks = new Set();
+    if (cells.length * (2 * gapCells + 1) ** 2 > 1_000_000)
+        throw new RangeError("Territory neighborhood is too large");
+    for (const cell of cells) {
+        key(cell);
+        for (let x = cell.x - gapCells; x <= cell.x + gapCells; x++) {
+            for (let z = cell.z - gapCells; z <= cell.z + gapCells; z++)
+                chunks.add(territoryChunkKey({ x, z }, policy));
+        }
+    }
+    return [...chunks];
+}
+/**
+ * Owner of a loaded cell; hosts load the target and gap neighborhood before evaluating claims.
+ * @capability territory-owner-query Read a loaded land cell owner for authoritative placement checks.
+ */
+export function territoryOwnerOf(snapshot, cell, policy = {}) {
+    return snapshot.chunks[territoryChunkKey(cell, policy)]?.territory?.[key(cell)] ?? null;
+}
+/**
+ * Cells touched by a placement, excluding cells that only touch its outer edge.
+ * @capability territory-footprint Resolve exactly the ownership cells touched by a placement footprint.
+ */
+export function territoryFootprintCells(bounds, cellSize = 1) {
+    if (!Number.isFinite(cellSize) || cellSize <= 0 || !Object.values(bounds).every(Number.isFinite) || bounds.maxX <= bounds.minX || bounds.maxZ <= bounds.minZ)
+        throw new RangeError("Invalid territory footprint");
+    const cells = [];
+    const minX = Math.floor(bounds.minX / cellSize), maxX = Math.ceil(bounds.maxX / cellSize) - 1;
+    const minZ = Math.floor(bounds.minZ / cellSize), maxZ = Math.ceil(bounds.maxZ / cellSize) - 1;
+    if ((maxX - minX + 1) * (maxZ - minZ + 1) > 65536)
+        throw new RangeError("Territory footprint is too large");
+    for (let x = minX; x <= maxX; x++)
+        for (let z = minZ; z <= maxZ; z++)
+            cells.push({ x, z });
+    return cells;
+}
+/** Price and validate a footprint without mutating or charging; reuse for placement previews. */
+export function planFootprintClaims(snapshot, userId, footprint, policy = {}) {
+    const { gapCells } = checked(policy);
+    if (footprint.length * (2 * gapCells + 1) ** 2 > 1_000_000)
+        throw new RangeError("Territory neighborhood is too large");
+    const player = snapshot.players[userId];
+    if (!player)
+        return { ok: false, reason: "territory.blocked" };
+    const cells = [], seen = new Set();
+    let cost = 0;
+    const owned = Number(player.territoryOwnedCount ?? 0);
+    if (!Number.isSafeInteger(owned) || owned < 0)
+        throw new RangeError("Invalid territory owned count");
+    for (const cell of footprint) {
+        const cellKey = key(cell);
+        if (seen.has(cellKey))
+            continue;
+        seen.add(cellKey);
+        const owner = territoryOwnerOf(snapshot, cell, policy);
+        if (owner === userId)
+            continue;
+        if (owner !== null)
+            return { ok: false, reason: "territory.blocked" };
+        for (let x = cell.x - gapCells; x <= cell.x + gapCells; x++)
+            for (let z = cell.z - gapCells; z <= cell.z + gapCells; z++) {
+                const neighbor = territoryOwnerOf(snapshot, { x, z }, policy);
+                if (neighbor !== null && neighbor !== userId)
+                    return { ok: false, reason: "territory.blocked" };
+            }
+        const price = policy.price?.(owned + cells.length) ?? 0;
+        if (!Number.isFinite(price) || price < 0)
+            throw new RangeError("Invalid territory price");
+        cost += price;
+        if (!Number.isFinite(cost))
+            throw new RangeError("Invalid territory cost");
+        cells.push(cell);
+    }
+    if (cost > 0 && (!policy.currency || (player.economy[policy.currency] ?? 0) < cost))
+        return { ok: false, reason: "territory.unaffordable" };
+    return { ok: true, cells, cost };
+}
+/** Atomically buy every unowned footprint cell, leaving the input untouched on failure. */
+export function claimTerritory(snapshot, userId, cells, policy = {}) {
+    const plan = planFootprintClaims(snapshot, userId, cells, policy);
+    if (!plan.ok)
+        return plan;
+    let next = snapshot;
+    for (const [index, cell] of plan.cells.entries())
+        next = updateChunk(next, territoryChunkKey(cell, policy), chunk => ({
+            ...chunk,
+            territory: { ...chunk.territory, [key(cell)]: userId },
+            territoryReceipts: { ...chunk.territoryReceipts, [key(cell)]: { claimedAt: policy.nowMs ?? 0, costPaid: policy.price?.(Number(snapshot.players[userId]?.territoryOwnedCount ?? 0) + index) ?? 0 } },
+        }));
+    if (plan.cells.length === 0)
+        return { ok: true, snapshot, cost: 0 };
+    const player = snapshot.players[userId];
+    next = { ...next, players: { ...next.players, [userId]: { ...player, territoryOwnedCount: Number(player.territoryOwnedCount ?? 0) + plan.cells.length, ownedTerritoryChunkKeys: [...new Set([...(player.ownedTerritoryChunkKeys ?? []), ...plan.cells.map(cell => territoryChunkKey(cell, policy))])], economy: policy.currency ? { ...player.economy, [policy.currency]: (player.economy[policy.currency] ?? 0) - plan.cost } : player.economy } }, dirty: { ...next.dirty, players: [...new Set([...next.dirty.players, userId])] } };
+    return { ok: true, snapshot: next, cost: plan.cost };
+}
+/**
+ * Placement transaction: rejected object placement also rolls back territory and its charge.
+ * @capability territory-placement Purchase footprint cells atomically with object placement.
+ */
+export function placeWithTerritory(snapshot, userId, bounds, policy, place) {
+    const claimed = claimTerritory(snapshot, userId, territoryFootprintCells(bounds, policy.cellSize), policy);
+    if (!claimed.ok)
+        return claimed;
+    const placed = place(claimed.snapshot);
+    return placed.ok ? { ...placed, cost: claimed.cost } : placed;
+}
+/**
+ * Snapshot-backed territory facade with host-owned storage and live policy.
+ * @capability territory-ownership Claim, release and query land through host-owned snapshot storage.
+ */
+export function createTerritory(storage, policy = () => ({})) {
+    return {
+        snapshot: () => storage.get(),
+        restore: (snapshot) => storage.set(snapshot),
+        ownerOf: (cell) => territoryOwnerOf(storage.get(), cell, policy()),
+        canUse: (userId, cell) => territoryOwnerOf(storage.get(), cell, policy()) === userId,
+        claim(userId, cells) {
+            const result = claimTerritory(storage.get(), userId, cells, policy());
+            if (result.ok)
+                storage.set(result.snapshot);
+            return result;
+        },
+        release(userId, cell) {
+            const snapshot = storage.get(), config = policy();
+            if (territoryOwnerOf(snapshot, cell, config) !== userId || !snapshot.players[userId])
+                return false;
+            let next = updateChunk(snapshot, territoryChunkKey(cell, config), chunk => {
+                const territory = { ...chunk.territory }, territoryReceipts = { ...chunk.territoryReceipts };
+                delete territory[key(cell)];
+                delete territoryReceipts[key(cell)];
+                return { ...chunk, territory, territoryReceipts };
+            });
+            const player = next.players[userId];
+            next = { ...next, players: { ...next.players, [userId]: { ...player, territoryOwnedCount: Math.max(0, Number(player.territoryOwnedCount ?? 0) - 1), ownedTerritoryChunkKeys: (player.ownedTerritoryChunkKeys ?? []).filter(chunkKey => chunkKey !== territoryChunkKey(cell, config) || Object.values(next.chunks[chunkKey]?.territory ?? {}).includes(userId)) } }, dirty: { ...next.dirty, players: [...new Set([...next.dirty.players, userId])] } };
+            storage.set(next);
+            return true;
+        },
+        grantStarter(userId, center) {
+            const config = policy(), width = config.starterBlock ?? 3;
+            if (!Number.isSafeInteger(width) || width < 1 || width > 128)
+                throw new RangeError("Invalid starter block");
+            const snapshot = storage.get();
+            if (Number(snapshot.players[userId]?.territoryOwnedCount ?? 0) > 0)
+                return { ok: true, snapshot, cost: 0 };
+            const startX = center.x - Math.floor(width / 2), startZ = center.z - Math.floor(width / 2);
+            const cells = territoryFootprintCells({ minX: startX, minZ: startZ, maxX: startX + width, maxZ: startZ + width });
+            const result = claimTerritory(snapshot, userId, cells, { ...config, price: () => 0 });
+            if (result.ok)
+                storage.set(result.snapshot);
+            return result;
+        },
+    };
+}

package/dist/world.d.ts

@@ -21,6 +21,7 @@ export { evaluateQteSequence, pendingQteStep, type QteStep } from "./interaction
 export { evaluateSkillCheck, skillCheckZoneAt, type SkillCheckConfig, type SkillCheckResult, } from "./interaction/skillCheck.js";
 export { resolveLocalAvoidance, type AvoidanceAgent, type LocalAvoidanceOptions } from "./movement/avoidance.js";
 export { assignFormationSlots, boxFormation, circleFormation, facingYaw, lineFormation, placeFormation, wedgeFormation, type BoxFormationOptions, type CircleFormationOptions, type FormationSlotGenerator, type LineFormationOptions, type SlotAssignmentOptions, type WedgeFormationOptions, } from "./movement/formation.js";
+export { CREATIVE_FLIGHT_TUNING, HOVER_FLIGHT_TUNING, NOCLIP_FLIGHT_TUNING, SPECTATOR_FLIGHT_TUNING, advanceFreeFlight, createFreeFlightController, createFreeFlightState, resolveFlightStep, resolveFreeFlightIntent, resolveFreeFlightIntentFromInput, type FreeFlightBindings, type FreeFlightController, type FreeFlightIntent, type FreeFlightMode, type FreeFlightState, type FreeFlightStep, type FreeFlightTuning, } from "./movement/freeFlight.js";
 export { createGlideModel } from "./movement/glideModel.js";
 export { createGrappleSwing } from "./movement/grappleSwing.js";
 export { createLeaderTrail } from "./movement/leaderTrail.js";
@@ -31,6 +32,7 @@ export { steerYaw } from "./movement/steering.js";
 export { constrainToNavGrid } from "./nav/navConstrain.js";
 export { populateNavGridFromEnvironment } from "./nav/navFromEnvironment.js";
 export { createNavGrid, findPath, slopeStepCost, type NavGrid, type NavPoint } from "./nav/navGrid.js";
+export { buildNavAdjacency, closestPoint, raycastNav, type NavMeshAdjacency, type NavMeshData, type NavMeshLink, type NavMeshPath, } from "./nav/navMesh.js";
 export { advancePathFollow, createPathFollow, pathFollowProgress, pathFollowSeek, pathFromNav, pathLength, type PathFollowConfig, type PathFollowProgress, type PathFollowState, type PathProgress, type Waypoint, } from "./nav/pathFollow.js";
 export { defineAttackMoveOrder, defineHoldOrder, defineMoveOrder, definePatrolOrder, defineStopOrder, defineTargetedOrder, type AttackMoveOrderPayload, type EmptyOrderPayload, type EngagementKindConfig, type EngagementOrderState, type MoveOrderPayload, type OrderKindConfig, type OrderMoveResult, type OrderMover, type OrderTargeting, type PatrolOrderPayload, type PatrolOrderState, type TargetedOrderPayload, } from "./orders/orderKinds.js";
 export { createOrderQueue, createOrderRegistry, type Order, type OrderCancelReason, type OrderEvent, type OrderIssueResult, type OrderKind, type OrderOutcome, type OrderPhase, type OrderProgress, type OrderQueue, type OrderQueueOptions, type OrderQueuePolicy, type OrderQueueState, type OrderRegistry, type OrderRejection, type OrderRequest, type OrderStartResult, type OrderTickReport, type OrderVec3, } from "./orders/orderQueue.js";
@@ -39,7 +41,7 @@ export { createBuoyantBody } from "./physics/buoyancy.js";
 export { Carryable, carrySpeedMultiplier } from "./physics/carryable.js";
 export { createDamageModel } from "./physics/damageZones.js";
 export { tickDrivableVehicle } from "./physics/drivableVehicle.js";
-export { createAircraftDynamics, type AircraftDynamics, type AircraftKind, type AircraftOptions, type AircraftStep, type AircraftTuning, type FlightControlInput, type FlightControlRates, type FlightVector, } from "./physics/flightDynamics.js";
+export { createAircraftDynamics, type AircraftAxis, type AircraftDynamics, type AircraftKind, type AircraftOptions, type AircraftStep, type AircraftTuning, type FlightControlInput, type FlightControlRates, type FlightVector, } from "./physics/flightDynamics.js";
 export { ForceVolume, PlatformCarry } from "./physics/forceVolume.js";
 export { combineGravity, pointGravity, uniformGravity, type GravityField, type GravityVector, type PointGravityOptions, } from "./physics/gravityField.js";
 export { createKinematicVehicle, type KinematicChassisTuning, type KinematicDynamicsTuning, type KinematicPowertrainTuning, type KinematicSteeringTuning, type KinematicVehicle, type KinematicVehicleStep, type KinematicVehicleTuning, } from "./physics/kinematicVehicle.js";
@@ -56,8 +58,8 @@ export { partsBounds, registerAssetGenerator, type GeneratedAsset, type Generate
 export { applyRotationPolicy, headingToRotationY, normalizeDegrees, parseAssetSpace, parseRotationPolicy, resolveAnchorOffset, resolveFacingRotationY, rotatedFootprint, rotationYToHeading, snapHeading, toEngineUnits, validateAssetSpace, type AssetAnchor, type AssetSpace, type AssetSpaceIssue, type PlacementRotationPolicy, } from "./scene/assetSpace.js";
 export { collectAuthoredTriggers, createAuthoredTriggerRuntime, getTriggerAction, listTriggerActions, pointInVolume, registerTriggerAction, type AuthoredTrigger, type AuthoredTriggerRuntime, type TriggerActionDefinition, type TriggerDispatchEvent, type TriggerEvent, type TriggerHandlers, type TriggerSourceKind, } from "./scene/authoredTriggers.js";
 export { selectAutoTarget, type AutoTargetPolicy } from "./scene/autoTarget.js";
-export { advanceBehaviors, behaviorControl, type BehaviorControl, type BehaviorInspection, type BehaviorResumePolicy, type BehaviorSnapshot, type BehaviorStatus, } from "./scene/behaviorRuntime.js";
-export { patrol, player, talkable, wander, type BehaviorDescriptor } from "./scene/behaviors.js";
+export { advanceBehaviors, behaviorControl, registerBehaviorActions, type BehaviorAction, type BehaviorActionContext, type BehaviorControl, type BehaviorInspection, type BehaviorResumePolicy, type BehaviorSnapshot, type BehaviorStatus, } from "./scene/behaviorRuntime.js";
+export { patrol, player, talkable, wander, type BehaviorDescriptor, type DecisionGraphBehavior, } from "./scene/behaviors.js";
 export { createBodyBind } from "./scene/bodyBind.js";
 export { type ColliderPurpose, type EntityColliderSet, type ResolvedCollider } from "./scene/colliders.js";
 export { type StatCatalog, type StatValue } from "./scene/entityStats.js";

package/dist/world.js

@@ -21,6 +21,7 @@ export { evaluateQteSequence, pendingQteStep } from "./interaction/qte.js";
 export { evaluateSkillCheck, skillCheckZoneAt, } from "./interaction/skillCheck.js";
 export { resolveLocalAvoidance } from "./movement/avoidance.js";
 export { assignFormationSlots, boxFormation, circleFormation, facingYaw, lineFormation, placeFormation, wedgeFormation, } from "./movement/formation.js";
+export { CREATIVE_FLIGHT_TUNING, HOVER_FLIGHT_TUNING, NOCLIP_FLIGHT_TUNING, SPECTATOR_FLIGHT_TUNING, advanceFreeFlight, createFreeFlightController, createFreeFlightState, resolveFlightStep, resolveFreeFlightIntent, resolveFreeFlightIntentFromInput, } from "./movement/freeFlight.js";
 export { createGlideModel } from "./movement/glideModel.js";
 export { createGrappleSwing } from "./movement/grappleSwing.js";
 export { createLeaderTrail } from "./movement/leaderTrail.js";
@@ -31,6 +32,7 @@ export { steerYaw } from "./movement/steering.js";
 export { constrainToNavGrid } from "./nav/navConstrain.js";
 export { populateNavGridFromEnvironment } from "./nav/navFromEnvironment.js";
 export { createNavGrid, findPath, slopeStepCost } from "./nav/navGrid.js";
+export { buildNavAdjacency, closestPoint, raycastNav, } from "./nav/navMesh.js";
 export { advancePathFollow, createPathFollow, pathFollowProgress, pathFollowSeek, pathFromNav, pathLength, } from "./nav/pathFollow.js";
 export { defineAttackMoveOrder, defineHoldOrder, defineMoveOrder, definePatrolOrder, defineStopOrder, defineTargetedOrder, } from "./orders/orderKinds.js";
 export { createOrderQueue, createOrderRegistry, } from "./orders/orderQueue.js";
@@ -56,8 +58,8 @@ export { partsBounds, registerAssetGenerator } from "./scene/assetGenerator.js";
 export { applyRotationPolicy, headingToRotationY, normalizeDegrees, parseAssetSpace, parseRotationPolicy, resolveAnchorOffset, resolveFacingRotationY, rotatedFootprint, rotationYToHeading, snapHeading, toEngineUnits, validateAssetSpace, } from "./scene/assetSpace.js";
 export { collectAuthoredTriggers, createAuthoredTriggerRuntime, getTriggerAction, listTriggerActions, pointInVolume, registerTriggerAction, } from "./scene/authoredTriggers.js";
 export { selectAutoTarget } from "./scene/autoTarget.js";
-export { advanceBehaviors, behaviorControl, } from "./scene/behaviorRuntime.js";
-export { patrol, player, talkable, wander } from "./scene/behaviors.js";
+export { advanceBehaviors, behaviorControl, registerBehaviorActions, } from "./scene/behaviorRuntime.js";
+export { patrol, player, talkable, wander, } from "./scene/behaviors.js";
 export { createBodyBind } from "./scene/bodyBind.js";
 export {} from "./scene/colliders.js";
 export {} from "./scene/entityStats.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jgengine/core",
-  "version": "0.17.0",
+  "version": "0.18.1",
   "description": "jgengine core — pure-TypeScript game framework SDK (npm @jgengine/core). Entity stores, commands, combat, inventory, multiplayer seams. Zero dependencies. Not an ECS. Agent skills ship in the tarball. https://jgengine.com",
   "keywords": [
     "jgengine",

package/skills/ce-handoff/SKILL.md

@@ -146,4 +146,4 @@ When sufficient, return a concise orientation: objective, progress, decisions, c
 - Multi-session engine work often spans `docs/plans/`, GitHub issues, and stacked PRs — point at those; do not paste full plan bodies.
 - Prefer `bun run agent:bootstrap --check` status, branch names, and PR links as state anchors.
 - Local parallelism uses `.claude/worktrees/`; never invent `C:\tmp\…` Codex-shared trees.
-- Papercuts and durable process changes belong in `PAPERCUTS.md` / skills, not only the handoff.
+- Durable process changes belong in skills, not only the handoff.

package/skills/game-design/SKILL.md

@@ -11,7 +11,7 @@ Own the intended player experience and the rules that produce it: fantasy, pilla
 
 Use `level-design` for spatial realization; route implementation to `jgengine-gameplay`, `jgengine-world`, `jgengine-combat`, `jgengine-ui`, `jgengine-multiplayer` once intent is coherent.
 
-Read [references/application-playbook.md](references/application-playbook.md) only when the task explicitly calls for design depth — a design brief, a redesign, or "make this fun/better" work; it is not a mandatory step of creating a game. Read [references/field-guide.md](references/field-guide.md) when the task needs deeper loop, economy, progression, genre, accessibility, or research guidance.
+For a greenfield build, read [references/application-playbook.md](references/application-playbook.md) and produce its greenfield contract (promise, pillars, anti-pillars, core decision, and falsifier) before writing code. Audits may read only the playbook's audit sections. Read [references/field-guide.md](references/field-guide.md) when the task needs deeper loop, economy, progression, genre, accessibility, or research guidance.
 
 ## Choose the mode
 
@@ -28,3 +28,13 @@ Every design pass yields an observed journey, a north star (promise, pillars, an
 An audit is not completion for a build/improve request. Finish when the slice is playable, a fresh player can state goal/choice/consequence, failure/recovery behave as intended, and evidence supports the pillars. Use `jgengine-verify` and `workflow` to ship.
 
 **Required: player death is a designed, visible moment.** If the game can kill or down the player, death is part of the experience contract, not an invisible state reset. A lethal hit must resolve into an authored beat the player perceives and understands — a death or downed moment, the stakes it carries, and a legible path back into play (respawn, revive, restart) — never a silent teleport to spawn. Design what death means for this pitch (permadeath, checkpoint, bleed-out-and-revive, run reset) and treat "player dies with no acknowledged consequence" as a failure/recovery defect. `jgengine-ui` owns building the screen and respawn feedback.
+
+## Persistent-builder checks
+
+Before content, write a first-hour balance sheet: starting cash, time to first income, net income per hour at starting hardware and at ten times that hardware, bill cadence versus income, and the insolvency recovery path. Insolvency resets the affected player or changes their options; it never deletes the world. Express clicks and event rewards as a fraction of the designed income rate, never an unrelated flat payout.
+
+Declare currency `decimals` for income paid per second. Anchor time-based decay to `game.createdAt` or a persisted per-instance creation time, never a fixed wall-clock epoch. Test fractional income over real tick cadences before tuning prices.
+
+The first-60-seconds gate requires the first tutorial verb to be executable from spawn with starting inventory. Grant dependencies such as land, power, and slots or let players buy them in-context; the tutorial cannot lock the surface needed to complete itself. Placement previews show cost and affordability inline.
+
+For a persistent shared-world builder, compose neighborhood presence, declared command read scopes, membership storage, online-player batched ticks, territory, chat, and join retry UI through their engine owners. Verify capacity and first-player onboarding before scaling the content catalog.

package/skills/jgengine/SKILL.md

@@ -9,6 +9,8 @@ Read the JGengine README for package truth, commands, layering, and license —
 
 ## 1. Establish the target
 
+For greenfield builds, write `src/art-direction.md` before any code.
+
 Treat the pitch as a unique composition of needs, not a genre to fill in — never reach for a genre kit, preset, archetype, or class template ("default sports car", "default RPG", "default FPS") in the SDK or skills (see [AGENTS.md](../../../AGENTS.md)). Use `game-design` to turn the pitch into a testable player promise, verbs, loops, progression, failure, and completion scenario. Use `level-design` when play depends on authored spaces, routes, encounters, exploration, or spatial pacing. Capture only decisions that change architecture:
 
 - player point of view and controls