@jgengine/core 0.8.0 → 0.10.0

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"];

package/dist/faction/factions.d.ts

@@ -0,0 +1,33 @@
+export type FactionRelation = "hostile" | "neutral" | "friendly";
+export interface FactionDef {
+    id: string;
+    relations?: Readonly<Record<string, FactionRelation>>;
+    towardSelf?: FactionRelation;
+    towardOthers?: FactionRelation;
+}
+export interface FactionGraphConfig {
+    factions: readonly FactionDef[];
+    symmetric?: boolean;
+    unaligned?: FactionRelation;
+}
+export interface FactionGraph {
+    relationBetween(observer: string | null | undefined, other: string | null | undefined): FactionRelation;
+    isHostile(observer: string | null | undefined, other: string | null | undefined): boolean;
+    isFriendly(observer: string | null | undefined, other: string | null | undefined): boolean;
+    isNeutral(observer: string | null | undefined, other: string | null | undefined): boolean;
+    has(factionId: string): boolean;
+    ids(): string[];
+}
+export declare function createFactionGraph(config: FactionGraphConfig): FactionGraph;
+export interface FactionRoster {
+    assign(entityId: string, factionId: string | null): void;
+    factionOf(entityId: string): string | null;
+    relationBetweenEntities(observer: string, other: string): FactionRelation;
+    isHostile(observer: string, other: string): boolean;
+    isFriendly(observer: string, other: string): boolean;
+    members(factionId: string): string[];
+    hostilesOf(observer: string, candidates: Iterable<string>): string[];
+    remove(entityId: string): void;
+    clear(): void;
+}
+export declare function createFactionRoster(graph: FactionGraph): FactionRoster;

package/dist/faction/factions.js

@@ -0,0 +1,76 @@
+export function createFactionGraph(config) {
+    const symmetric = config.symmetric ?? true;
+    const unaligned = config.unaligned ?? "neutral";
+    const defs = new Map();
+    for (const def of config.factions)
+        defs.set(def.id, def);
+    function relationBetween(observer, other) {
+        if (observer == null || other == null)
+            return unaligned;
+        const from = defs.get(observer);
+        const to = defs.get(other);
+        if (from === undefined || to === undefined)
+            return unaligned;
+        if (observer === other)
+            return from.towardSelf ?? "friendly";
+        const direct = from.relations?.[other];
+        if (direct !== undefined)
+            return direct;
+        if (symmetric) {
+            const mirrored = to.relations?.[observer];
+            if (mirrored !== undefined)
+                return mirrored;
+        }
+        return from.towardOthers ?? "neutral";
+    }
+    return {
+        relationBetween,
+        isHostile: (observer, other) => relationBetween(observer, other) === "hostile",
+        isFriendly: (observer, other) => relationBetween(observer, other) === "friendly",
+        isNeutral: (observer, other) => relationBetween(observer, other) === "neutral",
+        has: (factionId) => defs.has(factionId),
+        ids: () => [...defs.keys()],
+    };
+}
+export function createFactionRoster(graph) {
+    const membership = new Map();
+    function factionOf(entityId) {
+        return membership.get(entityId) ?? null;
+    }
+    function relationBetweenEntities(observer, other) {
+        return graph.relationBetween(factionOf(observer), factionOf(other));
+    }
+    return {
+        assign(entityId, factionId) {
+            if (factionId === null)
+                membership.delete(entityId);
+            else
+                membership.set(entityId, factionId);
+        },
+        factionOf,
+        relationBetweenEntities,
+        isHostile: (observer, other) => relationBetweenEntities(observer, other) === "hostile",
+        isFriendly: (observer, other) => relationBetweenEntities(observer, other) === "friendly",
+        members(factionId) {
+            const out = [];
+            for (const [entityId, id] of membership)
+                if (id === factionId)
+                    out.push(entityId);
+            return out;
+        },
+        hostilesOf(observer, candidates) {
+            const out = [];
+            for (const id of candidates) {
+                if (id !== observer && relationBetweenEntities(observer, id) === "hostile")
+                    out.push(id);
+            }
+            return out;
+        },
+        remove(entityId) {
+            membership.delete(entityId);
+        },
+        clear() {
+            membership.clear();
+        },
+    };
+}

package/dist/faction/reputation.d.ts

@@ -0,0 +1,32 @@
+import type { FactionRelation } from "./factions.js";
+export interface ReputationTier {
+    id: string;
+    min: number;
+    relation: FactionRelation;
+}
+export declare const DEFAULT_REPUTATION_TIERS: readonly ReputationTier[];
+export declare function tierForStanding(tiers: readonly ReputationTier[], standing: number): ReputationTier;
+export interface ReputationLedgerConfig {
+    tiers?: readonly ReputationTier[];
+    initial?: Readonly<Record<string, number>>;
+    min?: number;
+    max?: number;
+}
+export interface ReputationLedger {
+    standing(actorId: string, factionId: string): number;
+    hasStanding(actorId: string, factionId: string): boolean;
+    gain(actorId: string, factionId: string, amount: number): number;
+    set(actorId: string, factionId: string, standing: number): number;
+    tier(actorId: string, factionId: string): ReputationTier;
+    relation(actorId: string, factionId: string): FactionRelation;
+    standings(actorId: string): Record<string, number>;
+    reset(actorId: string, factionId?: string): void;
+}
+export declare function createReputationLedger(config?: ReputationLedgerConfig): ReputationLedger;
+export interface EffectiveRelationInput {
+    base: FactionRelation;
+    ledger: ReputationLedger;
+    actorId: string;
+    factionId: string;
+}
+export declare function effectiveRelation(input: EffectiveRelationInput): FactionRelation;