@jgengine/core 0.9.0 → 0.10.0

package/dist/combat/shotOrigin.d.ts

@@ -1,14 +1,20 @@
 import type { EntityPosition } from "../scene/entityStore.js";
+import { type EntityColliderSet } from "../scene/colliders.js";
 import type { Aim } from "../scene/spatial.js";
 /**
  * How a shot's world-space origin (and optional direction) is resolved before prediction/settlement.
- * - `legacy` — `aim.origin` when present, else the shooter's entity position (pre-#431 default).
+ * - `eye` — `aim.origin` when present, else the shooter's entity position raised to eye height; the
+ *   shot traces the shooter's sightline, so what the crosshair covers is what gets hit (the default).
+ * - `legacy` — `aim.origin` when present, else the shooter's raw entity position (feet).
  * - `entity` — always the shooter's entity position.
  * - `entityOffset` / `muzzle` — entity-local offset rotated by the shooter's yaw (muzzle on a weapon model).
  * - `camera` — explicit camera/reticle world origin (and optional direction override).
  * - `world` — absolute world origin.
  */
 export type ShotOriginPolicy = {
+    kind: "eye";
+    height?: number;
+} | {
     kind: "legacy";
 } | {
     kind: "entity";
@@ -34,7 +40,13 @@ export interface ResolvedShot {
 export interface ShotOriginDeps {
     positionOf(instanceId: string): EntityPosition | undefined;
     rotationYOf?(instanceId: string): number | undefined;
+    /** When provided, the `eye` policy sizes its height from the shooter's own hitbox instead of the humanoid default. */
+    collidersOf?(instanceId: string): EntityColliderSet | null | undefined;
 }
+/** Shot-origin and first-person camera eye height above an entity's position: 90% of the default 1.8m hitbox top. */
+export declare const DEFAULT_EYE_HEIGHT: number;
+/** Eye height derived from a collider set: 90% of the tallest hitbox top, or the humanoid default when unknown. */
+export declare function eyeHeightFromColliders(set: EntityColliderSet | null | undefined): number;
 export declare function aimDirection(aim: Aim): EntityPosition | null;
 export declare function aimSpreadDeg(aim: Aim): number;
 export declare function resolveShot(deps: ShotOriginDeps, from: string, aim: Aim, policy?: ShotOriginPolicy): ResolvedShot | null;

package/dist/combat/shotOrigin.js

@@ -1,5 +1,19 @@
-import { worldOffset } from "../scene/colliders.js";
+import { resolveColliders, worldOffset } from "../scene/colliders.js";
 const DEFAULT_MUZZLE_OFFSET = [0, 1.4, 0.35];
+const EYE_HEIGHT_RATIO = 0.9;
+/** Shot-origin and first-person camera eye height above an entity's position: 90% of the default 1.8m hitbox top. */
+export const DEFAULT_EYE_HEIGHT = EYE_HEIGHT_RATIO * 1.8;
+/** Eye height derived from a collider set: 90% of the tallest hitbox top, or the humanoid default when unknown. */
+export function eyeHeightFromColliders(set) {
+    const colliders = resolveColliders(set);
+    let top = 0;
+    for (const collider of colliders) {
+        const offsetY = collider.shape.offset?.[1] ?? 0;
+        const halfHeight = collider.shape.kind === "sphere" ? collider.shape.radius : collider.shape.halfExtents[1];
+        top = Math.max(top, offsetY + halfHeight);
+    }
+    return top > 0 ? top * EYE_HEIGHT_RATIO : DEFAULT_EYE_HEIGHT;
+}
 function normalize(vector) {
     const length = Math.sqrt(vector[0] * vector[0] + vector[1] * vector[1] + vector[2] * vector[2]);
     if (length === 0)
@@ -15,11 +29,26 @@ export function aimDirection(aim) {
 export function aimSpreadDeg(aim) {
     return "origin" in aim ? 0 : aim.spread ?? 0;
 }
-export function resolveShot(deps, from, aim, policy = { kind: "legacy" }) {
+export function resolveShot(deps, from, aim, policy = { kind: "eye" }) {
     const aimDir = aimDirection(aim);
     if (aimDir === null && policy.kind !== "camera" && policy.kind !== "world")
         return null;
     switch (policy.kind) {
+        case "eye": {
+            if ("origin" in aim) {
+                if (aimDir === null)
+                    return null;
+                return { origin: aim.origin, direction: aimDir };
+            }
+            const position = deps.positionOf(from);
+            if (position === undefined || aimDir === null)
+                return null;
+            const height = policy.height ??
+                (deps.collidersOf !== undefined
+                    ? eyeHeightFromColliders(deps.collidersOf(from))
+                    : DEFAULT_EYE_HEIGHT);
+            return { origin: [position[0], position[1] + height, position[2]], direction: aimDir };
+        }
         case "legacy": {
             const origin = "origin" in aim ? aim.origin : deps.positionOf(from);
             if (origin === undefined || aimDir === null)

package/dist/editor/commands.d.ts

@@ -0,0 +1,65 @@
+import type { EditorDocument, EditorMarker, EditorVec3, EditorVolume } from "./types.js";
+/** A single editor mutation — select, move, add, remove, undo/redo — dispatched to a session. */
+export type EditorCommand = {
+    type: "select";
+    ids: readonly string[];
+} | {
+    type: "clearSelection";
+} | {
+    type: "setTransform";
+    id: string;
+    position?: EditorVec3;
+    rotationY?: number;
+} | {
+    type: "addMarker";
+    marker: EditorMarker;
+} | {
+    type: "remove";
+    id: string;
+} | {
+    type: "setVolume";
+    id: string;
+    patch: Partial<Omit<EditorVolume, "id">>;
+} | {
+    type: "addVolume";
+    volume: EditorVolume;
+} | {
+    type: "importDocument";
+    document: EditorDocument;
+} | {
+    type: "importJson";
+    json: string;
+} | {
+    type: "replaceDocument";
+    document: EditorDocument;
+} | {
+    type: "undo";
+} | {
+    type: "redo";
+};
+/** The document plus current selection at a point in editor history. */
+export interface EditorSessionState {
+    document: EditorDocument;
+    selection: string[];
+}
+/** Stateful, undoable handle for driving scene edits from UI or an MCP agent. */
+export interface EditorSession {
+    getState(): EditorSessionState;
+    subscribe(listener: (state: EditorSessionState) => void): () => void;
+    dispatch(command: EditorCommand): EditorSessionState;
+    exportJson(pretty?: boolean): string;
+    canUndo(): boolean;
+    canRedo(): boolean;
+}
+/** Creates an editor session with undo/redo history seeded from an initial document. */
+export declare function createEditorSession(initial: EditorDocument, historyLimit?: number): EditorSession;
+/** Compact snapshot of a session state — counts, selection, and the selected object. */
+export declare function summarizeEditorSession(state: EditorSessionState): {
+    markers: number;
+    volumes: number;
+    paths: number;
+    annotations: number;
+    selection: string[];
+    selectedMarker?: EditorMarker;
+    selectedVolume?: EditorVolume;
+};

package/dist/editor/commands.js

@@ -0,0 +1,193 @@
+import { cloneEditorDocument, findEditorMarker, findEditorVolume, importEditorDocumentJson, } from "./document.js";
+function snapshotState(state) {
+    return {
+        document: cloneEditorDocument(state.document),
+        selection: [...state.selection],
+    };
+}
+function removeById(doc, id) {
+    return {
+        version: 1,
+        markers: doc.markers.filter((marker) => marker.id !== id),
+        volumes: doc.volumes.filter((volume) => volume.id !== id),
+        paths: doc.paths.filter((path) => path.id !== id),
+        annotations: doc.annotations.filter((note) => note.id !== id),
+    };
+}
+function applyMutating(state, command) {
+    switch (command.type) {
+        case "select":
+            return { ...state, selection: [...command.ids] };
+        case "clearSelection":
+            return { ...state, selection: [] };
+        case "setTransform": {
+            const markers = state.document.markers.map((marker) => {
+                if (marker.id !== command.id)
+                    return marker;
+                return {
+                    ...marker,
+                    position: command.position === undefined ? marker.position : { ...command.position },
+                    ...(command.rotationY === undefined ? {} : { rotationY: command.rotationY }),
+                };
+            });
+            const volumes = state.document.volumes.map((volume) => {
+                if (volume.id !== command.id)
+                    return volume;
+                if (command.position === undefined)
+                    return volume;
+                return { ...volume, center: { ...command.position } };
+            });
+            const annotations = state.document.annotations.map((note) => {
+                if (note.id !== command.id)
+                    return note;
+                if (command.position === undefined)
+                    return note;
+                return { ...note, position: { ...command.position } };
+            });
+            return {
+                ...state,
+                document: { ...state.document, markers, volumes, annotations },
+            };
+        }
+        case "addMarker":
+            return {
+                ...state,
+                document: {
+                    ...state.document,
+                    markers: [...state.document.markers.filter((m) => m.id !== command.marker.id), command.marker],
+                },
+                selection: [command.marker.id],
+            };
+        case "addVolume":
+            return {
+                ...state,
+                document: {
+                    ...state.document,
+                    volumes: [...state.document.volumes.filter((v) => v.id !== command.volume.id), command.volume],
+                },
+                selection: [command.volume.id],
+            };
+        case "setVolume": {
+            const volumes = state.document.volumes.map((volume) => {
+                if (volume.id !== command.id)
+                    return volume;
+                return {
+                    ...volume,
+                    ...command.patch,
+                    center: command.patch.center === undefined ? volume.center : { ...command.patch.center },
+                    halfExtents: command.patch.halfExtents === undefined
+                        ? volume.halfExtents
+                        : { ...command.patch.halfExtents },
+                    meta: command.patch.meta === undefined ? volume.meta : { ...command.patch.meta },
+                };
+            });
+            return { ...state, document: { ...state.document, volumes } };
+        }
+        case "remove":
+            return {
+                document: removeById(state.document, command.id),
+                selection: state.selection.filter((id) => id !== command.id),
+            };
+        case "importDocument":
+        case "replaceDocument":
+            return {
+                document: cloneEditorDocument(command.document),
+                selection: [],
+            };
+        case "importJson":
+            return {
+                document: importEditorDocumentJson(command.json),
+                selection: [],
+            };
+        case "undo":
+        case "redo":
+            return null;
+    }
+}
+function isStructural(command) {
+    return (command.type === "setTransform" ||
+        command.type === "addMarker" ||
+        command.type === "addVolume" ||
+        command.type === "setVolume" ||
+        command.type === "remove" ||
+        command.type === "importDocument" ||
+        command.type === "importJson" ||
+        command.type === "replaceDocument");
+}
+/** Creates an editor session with undo/redo history seeded from an initial document. */
+export function createEditorSession(initial, historyLimit = 100) {
+    let state = {
+        document: cloneEditorDocument(initial),
+        selection: [],
+    };
+    const past = [];
+    const future = [];
+    const listeners = new Set();
+    const emit = () => {
+        for (const listener of listeners)
+            listener(state);
+    };
+    return {
+        getState: () => state,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        canUndo: () => past.length > 0,
+        canRedo: () => future.length > 0,
+        dispatch(command) {
+            if (command.type === "undo") {
+                const previous = past.pop();
+                if (previous === undefined)
+                    return state;
+                future.push(snapshotState(state));
+                state = previous;
+                emit();
+                return state;
+            }
+            if (command.type === "redo") {
+                const next = future.pop();
+                if (next === undefined)
+                    return state;
+                past.push(snapshotState(state));
+                state = next;
+                emit();
+                return state;
+            }
+            const next = applyMutating(state, command);
+            if (next === null)
+                return state;
+            if (isStructural(command)) {
+                past.push(snapshotState(state));
+                if (past.length > historyLimit)
+                    past.shift();
+                future.length = 0;
+            }
+            state = next;
+            emit();
+            return state;
+        },
+        exportJson(pretty = true) {
+            return JSON.stringify(state.document, null, pretty ? 2 : undefined);
+        },
+    };
+}
+/** Compact snapshot of a session state — counts, selection, and the selected object. */
+export function summarizeEditorSession(state) {
+    const selectedId = state.selection[0];
+    return {
+        markers: state.document.markers.length,
+        volumes: state.document.volumes.length,
+        paths: state.document.paths.length,
+        annotations: state.document.annotations.length,
+        selection: [...state.selection],
+        ...(selectedId === undefined
+            ? {}
+            : {
+                selectedMarker: findEditorMarker(state.document, selectedId),
+                selectedVolume: findEditorVolume(state.document, selectedId),
+            }),
+    };
+}

package/dist/editor/document.d.ts

@@ -0,0 +1,40 @@
+import type { EditorDocument, EditorLayersInput, EditorMarker, EditorNote, EditorPath, EditorVolume } from "./types.js";
+/** Builds a fresh, empty editor document to start authoring a scene from scratch. */
+export declare function createEmptyEditorDocument(): EditorDocument;
+/** Deep-copies an editor document so edits never mutate the source. */
+export declare function cloneEditorDocument(doc: EditorDocument): EditorDocument;
+/** Resolves a game's `editorLayers` export — document, partial data, or factory — into a full document. */
+export declare function normalizeEditorLayers(input: EditorLayersInput | undefined | null): EditorDocument;
+/** Combines multiple editor documents' markers, volumes, paths, and notes into one. */
+export declare function mergeEditorDocuments(...docs: readonly EditorDocument[]): EditorDocument;
+/** Looks up a marker by id in an editor document. */
+export declare function findEditorMarker(doc: EditorDocument, id: string): EditorMarker | undefined;
+/** Looks up a volume by id in an editor document. */
+export declare function findEditorVolume(doc: EditorDocument, id: string): EditorVolume | undefined;
+/** Looks up a path by id in an editor document. */
+export declare function findEditorPath(doc: EditorDocument, id: string): EditorPath | undefined;
+/** Looks up an annotation note by id in an editor document. */
+export declare function findEditorNote(doc: EditorDocument, id: string): EditorNote | undefined;
+/** Lists the distinct marker, volume, and path kinds authored in a document. */
+export declare function listEditorKinds(doc: EditorDocument): {
+    markers: string[];
+    volumes: string[];
+    paths: string[];
+};
+/** Serializes an editor document to JSON text for saving or export. */
+export declare function exportEditorDocumentJson(doc: EditorDocument, pretty?: boolean): string;
+/** Parses JSON text back into a normalized editor document. */
+export declare function importEditorDocumentJson(raw: string): EditorDocument;
+/** Computes the world-space min/max bounds spanning every object in a document, or null if empty. */
+export declare function editorDocumentBounds(doc: EditorDocument): {
+    min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+} | null;

package/dist/editor/document.js

@@ -0,0 +1,153 @@
+/** Builds a fresh, empty editor document to start authoring a scene from scratch. */
+export function createEmptyEditorDocument() {
+    return {
+        version: 1,
+        markers: [],
+        volumes: [],
+        paths: [],
+        annotations: [],
+    };
+}
+/** Deep-copies an editor document so edits never mutate the source. */
+export function cloneEditorDocument(doc) {
+    return {
+        version: 1,
+        markers: doc.markers.map((marker) => ({
+            ...marker,
+            position: { ...marker.position },
+            ...(marker.meta === undefined ? {} : { meta: { ...marker.meta } }),
+        })),
+        volumes: doc.volumes.map((volume) => ({
+            ...volume,
+            center: { ...volume.center },
+            ...(volume.halfExtents === undefined ? {} : { halfExtents: { ...volume.halfExtents } }),
+            ...(volume.meta === undefined ? {} : { meta: { ...volume.meta } }),
+        })),
+        paths: doc.paths.map((path) => ({
+            ...path,
+            points: path.points.map((point) => ({ ...point })),
+            ...(path.meta === undefined ? {} : { meta: { ...path.meta } }),
+        })),
+        annotations: doc.annotations.map((note) => ({
+            ...note,
+            position: { ...note.position },
+            ...(note.meta === undefined ? {} : { meta: { ...note.meta } }),
+        })),
+    };
+}
+function asArray(value) {
+    return value === undefined ? [] : [...value];
+}
+/** Resolves a game's `editorLayers` export — document, partial data, or factory — into a full document. */
+export function normalizeEditorLayers(input) {
+    if (input === undefined || input === null)
+        return createEmptyEditorDocument();
+    const resolved = typeof input === "function" ? input() : input;
+    return {
+        version: 1,
+        markers: asArray(resolved.markers),
+        volumes: asArray(resolved.volumes),
+        paths: asArray(resolved.paths),
+        annotations: asArray(resolved.annotations),
+    };
+}
+/** Combines multiple editor documents' markers, volumes, paths, and notes into one. */
+export function mergeEditorDocuments(...docs) {
+    const out = createEmptyEditorDocument();
+    for (const doc of docs) {
+        out.markers.push(...doc.markers);
+        out.volumes.push(...doc.volumes);
+        out.paths.push(...doc.paths);
+        out.annotations.push(...doc.annotations);
+    }
+    return out;
+}
+/** Looks up a marker by id in an editor document. */
+export function findEditorMarker(doc, id) {
+    return doc.markers.find((marker) => marker.id === id);
+}
+/** Looks up a volume by id in an editor document. */
+export function findEditorVolume(doc, id) {
+    return doc.volumes.find((volume) => volume.id === id);
+}
+/** Looks up a path by id in an editor document. */
+export function findEditorPath(doc, id) {
+    return doc.paths.find((path) => path.id === id);
+}
+/** Looks up an annotation note by id in an editor document. */
+export function findEditorNote(doc, id) {
+    return doc.annotations.find((note) => note.id === id);
+}
+/** Lists the distinct marker, volume, and path kinds authored in a document. */
+export function listEditorKinds(doc) {
+    const markers = new Set();
+    const volumes = new Set();
+    const paths = new Set();
+    for (const marker of doc.markers)
+        markers.add(marker.kind);
+    for (const volume of doc.volumes)
+        volumes.add(volume.kind);
+    for (const path of doc.paths)
+        paths.add(path.kind);
+    return {
+        markers: [...markers].sort(),
+        volumes: [...volumes].sort(),
+        paths: [...paths].sort(),
+    };
+}
+/** Serializes an editor document to JSON text for saving or export. */
+export function exportEditorDocumentJson(doc, pretty = true) {
+    return JSON.stringify(doc, null, pretty ? 2 : undefined);
+}
+/** Parses JSON text back into a normalized editor document. */
+export function importEditorDocumentJson(raw) {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object") {
+        throw new Error("editor document must be an object");
+    }
+    return normalizeEditorLayers(parsed);
+}
+/** Computes the world-space min/max bounds spanning every object in a document, or null if empty. */
+export function editorDocumentBounds(doc) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let minZ = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let maxZ = -Infinity;
+    let any = false;
+    const include = (x, y, z) => {
+        any = true;
+        if (x < minX)
+            minX = x;
+        if (y < minY)
+            minY = y;
+        if (z < minZ)
+            minZ = z;
+        if (x > maxX)
+            maxX = x;
+        if (y > maxY)
+            maxY = y;
+        if (z > maxZ)
+            maxZ = z;
+    };
+    for (const marker of doc.markers) {
+        include(marker.position.x, marker.position.y, marker.position.z);
+    }
+    for (const volume of doc.volumes) {
+        include(volume.center.x, volume.center.y, volume.center.z);
+    }
+    for (const path of doc.paths) {
+        for (const point of path.points)
+            include(point.x, point.y, point.z);
+    }
+    for (const note of doc.annotations) {
+        include(note.position.x, note.position.y, note.position.z);
+    }
+    if (!any)
+        return null;
+    return {
+        min: { x: minX, y: minY, z: minZ },
+        max: { x: maxX, y: maxY, z: maxZ },
+    };
+}

package/dist/editor/index.d.ts

@@ -0,0 +1,30 @@
+/** The full authored scene: every marker, volume, path, and note for a game. */
+export type { EditorDocument } from "./types.js";
+/** Per-kind show/hide flags for the editor's layer panel. */
+export type { EditorKindVisibility } from "./types.js";
+/** Accepted shape for a game's `editorLayers` export: a document, partial data, or a factory. */
+export type { EditorLayersInput } from "./types.js";
+/** A placeable point object in the scene — spawn, mob, chest, POI, etc. */
+export type { EditorMarker } from "./types.js";
+/** A free-text annotation pinned to a world position for designers. */
+export type { EditorNote } from "./types.js";
+/** A polyline of points — road, corridor, patrol route — placed in the scene. */
+export type { EditorPath } from "./types.js";
+/** A world-space point used across editor markers, volumes, and paths. */
+export type { EditorVec3 } from "./types.js";
+/** A spatial region — zone, aggro range, capture area — placed in the scene. */
+export type { EditorVolume } from "./types.js";
+/** Collision shape a volume is rendered and tested as. */
+export type { EditorVolumeShape } from "./types.js";
+export { WELL_KNOWN_MARKER_KINDS, WELL_KNOWN_PATH_KINDS, WELL_KNOWN_VOLUME_KINDS, } from "./types.js";
+export { cloneEditorDocument, createEmptyEditorDocument, editorDocumentBounds, exportEditorDocumentJson, findEditorMarker, findEditorNote, findEditorPath, findEditorVolume, importEditorDocumentJson, listEditorKinds, mergeEditorDocuments, normalizeEditorLayers, } from "./document.js";
+/** Creates an editor session with undo/redo history seeded from an initial document. */
+export { createEditorSession } from "./commands.js";
+/** Compact snapshot of a session state — counts, selection, and the selected object. */
+export { summarizeEditorSession } from "./commands.js";
+/** A single editor mutation — select, move, add, remove, undo/redo — dispatched to a session. */
+export type { EditorCommand } from "./commands.js";
+/** Stateful, undoable handle for driving scene edits from UI or an MCP agent. */
+export type { EditorSession } from "./commands.js";
+/** The document plus current selection at a point in editor history. */
+export type { EditorSessionState } from "./commands.js";

package/dist/editor/index.js

@@ -0,0 +1,6 @@
+export { WELL_KNOWN_MARKER_KINDS, WELL_KNOWN_PATH_KINDS, WELL_KNOWN_VOLUME_KINDS, } from "./types.js";
+export { cloneEditorDocument, createEmptyEditorDocument, editorDocumentBounds, exportEditorDocumentJson, findEditorMarker, findEditorNote, findEditorPath, findEditorVolume, importEditorDocumentJson, listEditorKinds, mergeEditorDocuments, normalizeEditorLayers, } from "./document.js";
+/** Creates an editor session with undo/redo history seeded from an initial document. */
+export { createEditorSession } from "./commands.js";
+/** Compact snapshot of a session state — counts, selection, and the selected object. */
+export { summarizeEditorSession } from "./commands.js";

package/dist/editor/types.d.ts

@@ -0,0 +1,69 @@
+/** A world-space point used across editor markers, volumes, and paths. */
+export type EditorVec3 = {
+    x: number;
+    y: number;
+    z: number;
+};
+/** Collision shape a volume is rendered and tested as. */
+export type EditorVolumeShape = "sphere" | "cylinder" | "box";
+/** A placeable point object in the scene — spawn, mob, chest, POI, etc. */
+export interface EditorMarker {
+    id: string;
+    kind: string;
+    position: EditorVec3;
+    rotationY?: number;
+    color?: string;
+    label?: string;
+    meta?: Record<string, unknown>;
+}
+/** A spatial region — zone, aggro range, capture area — placed in the scene. */
+export interface EditorVolume {
+    id: string;
+    kind: string;
+    shape: EditorVolumeShape;
+    center: EditorVec3;
+    radius?: number;
+    height?: number;
+    halfExtents?: EditorVec3;
+    color?: string;
+    label?: string;
+    meta?: Record<string, unknown>;
+}
+/** A polyline of points — road, corridor, patrol route — placed in the scene. */
+export interface EditorPath {
+    id: string;
+    kind: string;
+    points: readonly EditorVec3[];
+    width?: number;
+    color?: string;
+    label?: string;
+    meta?: Record<string, unknown>;
+}
+/** A free-text annotation pinned to a world position for designers. */
+export interface EditorNote {
+    id: string;
+    text: string;
+    position: EditorVec3;
+    color?: string;
+    meta?: Record<string, unknown>;
+}
+/** The full authored scene: every marker, volume, path, and note for a game. */
+export interface EditorDocument {
+    version: 1;
+    markers: EditorMarker[];
+    volumes: EditorVolume[];
+    paths: EditorPath[];
+    annotations: EditorNote[];
+}
+/** Accepted shape for a game's `editorLayers` export: a document, partial data, or a factory. */
+export type EditorLayersInput = EditorDocument | Partial<Omit<EditorDocument, "version">> | (() => EditorDocument | Partial<Omit<EditorDocument, "version">>);
+/** Per-kind show/hide flags for the editor's layer panel. */
+export interface EditorKindVisibility {
+    [kind: string]: boolean;
+}
+/** Standard marker kinds recognized with default colors and behavior. */
+export declare const WELL_KNOWN_MARKER_KINDS: readonly ["player_spawn", "mob", "boss", "vendor", "chest", "travel", "npc", "poi", "prop", "goal", "branch"];
+/** Standard volume kinds recognized with default colors and behavior. */
+export declare const WELL_KNOWN_VOLUME_KINDS: readonly ["zone", "flatten", "cluster", "aggro", "leash", "discover", "capture", "prompt", "poi", "respawn_skip"];
+/** Standard path kinds recognized with default colors and behavior. */
+export declare const WELL_KNOWN_PATH_KINDS: readonly ["road", "corridor", "branch", "route"];

package/dist/editor/types.js

@@ -0,0 +1,29 @@
+/** Standard marker kinds recognized with default colors and behavior. */
+export const WELL_KNOWN_MARKER_KINDS = [
+    "player_spawn",
+    "mob",
+    "boss",
+    "vendor",
+    "chest",
+    "travel",
+    "npc",
+    "poi",
+    "prop",
+    "goal",
+    "branch",
+];
+/** Standard volume kinds recognized with default colors and behavior. */
+export const WELL_KNOWN_VOLUME_KINDS = [
+    "zone",
+    "flatten",
+    "cluster",
+    "aggro",
+    "leash",
+    "discover",
+    "capture",
+    "prompt",
+    "poi",
+    "respawn_skip",
+];
+/** Standard path kinds recognized with default colors and behavior. */
+export const WELL_KNOWN_PATH_KINDS = ["road", "corridor", "branch", "route"];