run-dmcp 0.1.0

package/dist/tools/character.js

@@ -0,0 +1,309 @@
+import { v4 as uuidv4 } from "uuid";
+import { getDatabase } from "../db/connection.js";
+import { safeJsonParse } from "../utils/json.js";
+import { gameEvents } from "../events/emitter.js";
+import { validateGameExists } from "./game.js";
+export function createCharacter(params) {
+    // Validate game exists to prevent orphaned records
+    validateGameExists(params.gameId);
+    const db = getDatabase();
+    const id = uuidv4();
+    const now = new Date().toISOString();
+    const status = {
+        health: 100,
+        maxHealth: 100,
+        conditions: [],
+        experience: 0,
+        level: 1,
+        ...params.status,
+    };
+    const stmt = db.prepare(`
+    INSERT INTO characters (id, game_id, name, is_player, attributes, skills, status, location_id, notes, voice, image_gen, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    stmt.run(id, params.gameId, params.name, params.isPlayer ? 1 : 0, JSON.stringify(params.attributes || {}), JSON.stringify(params.skills || {}), JSON.stringify(status), params.locationId || null, params.notes || "", params.voice ? JSON.stringify(params.voice) : null, params.imageGen ? JSON.stringify(params.imageGen) : null, now);
+    const character = {
+        id,
+        gameId: params.gameId,
+        name: params.name,
+        isPlayer: params.isPlayer,
+        attributes: params.attributes || {},
+        skills: params.skills || {},
+        status,
+        locationId: params.locationId || null,
+        notes: params.notes || "",
+        voice: params.voice || null,
+        imageGen: params.imageGen || null,
+        createdAt: now,
+    };
+    // Emit realtime event
+    gameEvents.emit({
+        type: "character:created",
+        gameId: params.gameId,
+        entityId: id,
+        entityType: "character",
+        timestamp: now,
+        data: { name: params.name, isPlayer: params.isPlayer },
+    });
+    return character;
+}
+export function getCharacter(id) {
+    const db = getDatabase();
+    const stmt = db.prepare(`SELECT * FROM characters WHERE id = ?`);
+    const row = stmt.get(id);
+    if (!row)
+        return null;
+    return {
+        id: row.id,
+        gameId: row.game_id,
+        name: row.name,
+        isPlayer: row.is_player === 1,
+        attributes: safeJsonParse(row.attributes, {}),
+        skills: safeJsonParse(row.skills, {}),
+        status: safeJsonParse(row.status, { health: 0, maxHealth: 0, conditions: [], experience: 0, level: 1 }),
+        locationId: row.location_id,
+        notes: row.notes,
+        voice: row.voice ? safeJsonParse(row.voice, null) : null,
+        imageGen: row.image_gen ? safeJsonParse(row.image_gen, null) : null,
+        createdAt: row.created_at,
+    };
+}
+export function updateCharacter(id, updates) {
+    const db = getDatabase();
+    const current = getCharacter(id);
+    if (!current)
+        return null;
+    const newName = updates.name ?? current.name;
+    const newAttributes = updates.attributes
+        ? { ...current.attributes, ...updates.attributes }
+        : current.attributes;
+    const newSkills = updates.skills
+        ? { ...current.skills, ...updates.skills }
+        : current.skills;
+    const newStatus = updates.status
+        ? { ...current.status, ...updates.status }
+        : current.status;
+    const newLocationId = updates.locationId !== undefined ? updates.locationId : current.locationId;
+    const newNotes = updates.notes ?? current.notes;
+    const newVoice = updates.voice !== undefined ? updates.voice : current.voice;
+    const newImageGen = updates.imageGen !== undefined ? updates.imageGen : current.imageGen;
+    const stmt = db.prepare(`
+    UPDATE characters
+    SET name = ?, attributes = ?, skills = ?, status = ?, location_id = ?, notes = ?, voice = ?, image_gen = ?
+    WHERE id = ?
+  `);
+    stmt.run(newName, JSON.stringify(newAttributes), JSON.stringify(newSkills), JSON.stringify(newStatus), newLocationId, newNotes, newVoice ? JSON.stringify(newVoice) : null, newImageGen ? JSON.stringify(newImageGen) : null, id);
+    const updated = {
+        ...current,
+        name: newName,
+        attributes: newAttributes,
+        skills: newSkills,
+        status: newStatus,
+        locationId: newLocationId,
+        notes: newNotes,
+        voice: newVoice,
+        imageGen: newImageGen,
+    };
+    // Emit realtime event
+    gameEvents.emit({
+        type: "character:updated",
+        gameId: current.gameId,
+        entityId: id,
+        entityType: "character",
+        timestamp: new Date().toISOString(),
+        data: { name: newName },
+    });
+    return updated;
+}
+export function deleteCharacter(id) {
+    const db = getDatabase();
+    const stmt = db.prepare(`DELETE FROM characters WHERE id = ?`);
+    const result = stmt.run(id);
+    return result.changes > 0;
+}
+export function listCharacters(gameId, filter) {
+    const db = getDatabase();
+    let query = `SELECT * FROM characters WHERE game_id = ?`;
+    const params = [gameId];
+    if (filter?.isPlayer !== undefined) {
+        query += ` AND is_player = ?`;
+        params.push(filter.isPlayer ? 1 : 0);
+    }
+    if (filter?.locationId !== undefined) {
+        query += ` AND location_id = ?`;
+        params.push(filter.locationId);
+    }
+    const stmt = db.prepare(query);
+    const rows = stmt.all(...params);
+    return rows.map((row) => ({
+        id: row.id,
+        gameId: row.game_id,
+        name: row.name,
+        isPlayer: row.is_player === 1,
+        attributes: safeJsonParse(row.attributes, {}),
+        skills: safeJsonParse(row.skills, {}),
+        status: safeJsonParse(row.status, { health: 0, maxHealth: 0, conditions: [], experience: 0, level: 1 }),
+        locationId: row.location_id,
+        notes: row.notes,
+        voice: row.voice ? safeJsonParse(row.voice, null) : null,
+        imageGen: row.image_gen ? safeJsonParse(row.image_gen, null) : null,
+        createdAt: row.created_at,
+    }));
+}
+/**
+ * Find a character by name (case-insensitive, fuzzy match).
+ * Returns the best match or null if no reasonable match found.
+ */
+export function getCharacterByName(gameId, name) {
+    const db = getDatabase();
+    const searchName = name.toLowerCase().trim();
+    // First try exact match (case-insensitive)
+    const exactMatch = db.prepare(`SELECT * FROM characters WHERE game_id = ? AND LOWER(name) = ?`).get(gameId, searchName);
+    if (exactMatch) {
+        return mapRowToCharacter(exactMatch);
+    }
+    // Try contains match
+    const containsMatch = db.prepare(`SELECT * FROM characters WHERE game_id = ? AND LOWER(name) LIKE ?`).get(gameId, `%${searchName}%`);
+    if (containsMatch) {
+        return mapRowToCharacter(containsMatch);
+    }
+    // Try matching just the last word (e.g., "Gannik" matches "Master Gannik")
+    const words = searchName.split(/\s+/);
+    if (words.length > 0) {
+        const lastName = words[words.length - 1];
+        const lastNameMatch = db.prepare(`SELECT * FROM characters WHERE game_id = ? AND LOWER(name) LIKE ?`).get(gameId, `%${lastName}%`);
+        if (lastNameMatch) {
+            return mapRowToCharacter(lastNameMatch);
+        }
+    }
+    return null;
+}
+// Helper function to map database row to Character
+function mapRowToCharacter(row) {
+    return {
+        id: row.id,
+        gameId: row.game_id,
+        name: row.name,
+        isPlayer: row.is_player === 1,
+        attributes: safeJsonParse(row.attributes, {}),
+        skills: safeJsonParse(row.skills, {}),
+        status: safeJsonParse(row.status, { health: 0, maxHealth: 0, conditions: [], experience: 0, level: 1 }),
+        locationId: row.location_id,
+        notes: row.notes,
+        voice: row.voice ? safeJsonParse(row.voice, null) : null,
+        imageGen: row.image_gen ? safeJsonParse(row.image_gen, null) : null,
+        createdAt: row.created_at,
+    };
+}
+export function moveCharacter(characterId, locationId) {
+    const db = getDatabase();
+    const stmt = db.prepare(`UPDATE characters SET location_id = ? WHERE id = ?`);
+    const result = stmt.run(locationId, characterId);
+    return result.changes > 0;
+}
+/**
+ * Modify a character's health - damage or heal in a single call.
+ * Use mode: "damage" to reduce health, mode: "heal" to restore health.
+ */
+export function modifyHealth(characterId, params) {
+    const character = getCharacter(characterId);
+    if (!character)
+        return null;
+    const previousHealth = character.status.health;
+    let newHealth;
+    if (params.mode === "damage") {
+        newHealth = Math.max(0, character.status.health - params.amount);
+    }
+    else {
+        newHealth = Math.min(character.status.maxHealth, character.status.health + params.amount);
+    }
+    const updated = updateCharacter(characterId, {
+        status: { health: newHealth },
+    });
+    if (!updated)
+        return null;
+    return { character: updated, previousHealth, newHealth };
+}
+export function addCondition(characterId, condition) {
+    const character = getCharacter(characterId);
+    if (!character)
+        return null;
+    if (!character.status.conditions.includes(condition)) {
+        return updateCharacter(characterId, {
+            status: {
+                conditions: [...character.status.conditions, condition],
+            },
+        });
+    }
+    return character;
+}
+export function removeCondition(characterId, condition) {
+    const character = getCharacter(characterId);
+    if (!character)
+        return null;
+    return updateCharacter(characterId, {
+        status: {
+            conditions: character.status.conditions.filter((c) => c !== condition),
+        },
+    });
+}
+/**
+ * Modify conditions on a character - add or remove in a single call.
+ * This consolidated function reduces the number of tool calls needed.
+ */
+export function modifyConditions(characterId, params) {
+    const character = getCharacter(characterId);
+    if (!character)
+        return null;
+    let conditions = [...character.status.conditions];
+    const added = [];
+    const removed = [];
+    // Remove conditions first (so we can re-add if needed)
+    if (params.remove) {
+        for (const condition of params.remove) {
+            if (conditions.includes(condition)) {
+                conditions = conditions.filter((c) => c !== condition);
+                removed.push(condition);
+            }
+        }
+    }
+    // Add new conditions
+    if (params.add) {
+        for (const condition of params.add) {
+            if (!conditions.includes(condition)) {
+                conditions.push(condition);
+                added.push(condition);
+            }
+        }
+    }
+    const updated = updateCharacter(characterId, {
+        status: { conditions },
+    });
+    if (!updated)
+        return null;
+    return { character: updated, added, removed };
+}
+export function renderCharacterSheet(characterId) {
+    const db = getDatabase();
+    const character = getCharacter(characterId);
+    if (!character)
+        return null;
+    // Get location name
+    let locationName = null;
+    if (character.locationId) {
+        const loc = db.prepare(`SELECT name FROM locations WHERE id = ?`).get(character.locationId);
+        locationName = loc?.name || null;
+    }
+    // Get inventory
+    const items = db.prepare(`SELECT name, properties FROM items WHERE owner_id = ? AND owner_type = 'character'`)
+        .all(characterId);
+    const inventory = items.map(item => {
+        const props = safeJsonParse(item.properties, {});
+        return { name: item.name, type: props.type };
+    });
+    return {
+        character,
+        locationName,
+        inventory,
+    };
+}

package/dist/tools/combat.d.ts

@@ -0,0 +1,13 @@
+import type { Combat } from "../types/index.js";
+export declare function startCombat(params: {
+    gameId: string;
+    locationId: string;
+    participantIds: string[];
+}): Combat;
+export declare function getCombat(id: string): Combat | null;
+export declare function getActiveCombat(gameId: string): Combat | null;
+export declare function nextTurn(combatId: string): Combat | null;
+export declare function addCombatLog(combatId: string, entry: string): Combat | null;
+export declare function removeParticipant(combatId: string, characterId: string): Combat | null;
+export declare function endCombat(combatId: string): Combat | null;
+export declare function getCurrentCombatant(combatId: string): string | null;

package/dist/tools/combat.js

@@ -0,0 +1,195 @@
+import { v4 as uuidv4 } from "uuid";
+import { getDatabase } from "../db/connection.js";
+import { safeJsonParse } from "../utils/json.js";
+import { gameEvents } from "../events/emitter.js";
+import { validateGameExists } from "./game.js";
+import { getCharacter } from "./character.js";
+import { roll } from "./dice.js";
+import { getRules } from "./rules.js";
+export function startCombat(params) {
+    // Validate game exists to prevent orphaned records
+    validateGameExists(params.gameId);
+    const db = getDatabase();
+    const id = uuidv4();
+    const rules = getRules(params.gameId);
+    // Validate all participants exist before processing (prevents race conditions)
+    const characters = params.participantIds.map((charId) => {
+        const character = getCharacter(charId);
+        if (!character) {
+            throw new Error(`Character '${charId}' not found. Cannot start combat with missing participants.`);
+        }
+        return { charId, character };
+    });
+    // Roll initiative for each validated participant
+    const participants = characters.map(({ charId, character }) => {
+        let initiative = 0;
+        if (rules) {
+            // Simple initiative based on a d20 roll
+            // The DM can configure this in combat rules
+            const initRoll = roll("1d20");
+            // Add dexterity modifier if available
+            const dexMod = character.attributes.dexterity
+                ? Math.floor((character.attributes.dexterity - 10) / 2)
+                : 0;
+            initiative = initRoll.total + dexMod;
+        }
+        else {
+            initiative = roll("1d20").total;
+        }
+        return {
+            characterId: charId,
+            initiative,
+            isActive: true,
+        };
+    });
+    // Sort by initiative (highest first)
+    participants.sort((a, b) => b.initiative - a.initiative);
+    const stmt = db.prepare(`
+    INSERT INTO combats (id, game_id, location_id, participants, current_turn, round, status, log)
+    VALUES (?, ?, ?, ?, 0, 1, 'active', '[]')
+  `);
+    stmt.run(id, params.gameId, params.locationId, JSON.stringify(participants));
+    const combat = {
+        id,
+        gameId: params.gameId,
+        locationId: params.locationId,
+        participants,
+        currentTurn: 0,
+        round: 1,
+        status: "active",
+        log: [],
+    };
+    // Emit realtime event
+    gameEvents.emit({
+        type: "combat:started",
+        gameId: params.gameId,
+        entityId: id,
+        entityType: "combat",
+        timestamp: new Date().toISOString(),
+        data: { participantCount: participants.length },
+    });
+    return combat;
+}
+export function getCombat(id) {
+    const db = getDatabase();
+    const stmt = db.prepare(`SELECT * FROM combats WHERE id = ?`);
+    const row = stmt.get(id);
+    if (!row)
+        return null;
+    return {
+        id: row.id,
+        gameId: row.game_id,
+        locationId: row.location_id,
+        participants: safeJsonParse(row.participants, []),
+        currentTurn: row.current_turn,
+        round: row.round,
+        status: row.status,
+        log: safeJsonParse(row.log, []),
+    };
+}
+export function getActiveCombat(gameId) {
+    const db = getDatabase();
+    const stmt = db.prepare(`SELECT * FROM combats WHERE game_id = ? AND status = 'active' LIMIT 1`);
+    const row = stmt.get(gameId);
+    if (!row)
+        return null;
+    return {
+        id: row.id,
+        gameId: row.game_id,
+        locationId: row.location_id,
+        participants: safeJsonParse(row.participants, []),
+        currentTurn: row.current_turn,
+        round: row.round,
+        status: row.status,
+        log: safeJsonParse(row.log, []),
+    };
+}
+export function nextTurn(combatId) {
+    const combat = getCombat(combatId);
+    if (!combat || combat.status !== "active")
+        return null;
+    const db = getDatabase();
+    // Find next active participant
+    let nextTurn = combat.currentTurn;
+    let round = combat.round;
+    let attempts = 0;
+    const maxAttempts = combat.participants.length;
+    do {
+        nextTurn = (nextTurn + 1) % combat.participants.length;
+        if (nextTurn === 0) {
+            round++;
+        }
+        attempts++;
+    } while (!combat.participants[nextTurn].isActive &&
+        attempts < maxAttempts);
+    // If no active participants, end combat
+    if (attempts >= maxAttempts) {
+        return endCombat(combatId);
+    }
+    const stmt = db.prepare(`
+    UPDATE combats SET current_turn = ?, round = ? WHERE id = ?
+  `);
+    stmt.run(nextTurn, round, combatId);
+    return {
+        ...combat,
+        currentTurn: nextTurn,
+        round,
+    };
+}
+export function addCombatLog(combatId, entry) {
+    const combat = getCombat(combatId);
+    if (!combat)
+        return null;
+    const db = getDatabase();
+    const log = [...combat.log, entry];
+    const stmt = db.prepare(`UPDATE combats SET log = ? WHERE id = ?`);
+    stmt.run(JSON.stringify(log), combatId);
+    return {
+        ...combat,
+        log,
+    };
+}
+export function removeParticipant(combatId, characterId) {
+    const combat = getCombat(combatId);
+    if (!combat)
+        return null;
+    const db = getDatabase();
+    const participants = combat.participants.map((p) => p.characterId === characterId ? { ...p, isActive: false } : p);
+    const stmt = db.prepare(`UPDATE combats SET participants = ? WHERE id = ?`);
+    stmt.run(JSON.stringify(participants), combatId);
+    // Check if combat should end
+    const activeCount = participants.filter((p) => p.isActive).length;
+    if (activeCount <= 1) {
+        return endCombat(combatId);
+    }
+    return {
+        ...combat,
+        participants,
+    };
+}
+export function endCombat(combatId) {
+    const combat = getCombat(combatId);
+    if (!combat)
+        return null;
+    const db = getDatabase();
+    const stmt = db.prepare(`UPDATE combats SET status = 'resolved' WHERE id = ?`);
+    stmt.run(combatId);
+    // Emit realtime event
+    gameEvents.emit({
+        type: "combat:ended",
+        gameId: combat.gameId,
+        entityId: combatId,
+        entityType: "combat",
+        timestamp: new Date().toISOString(),
+    });
+    return {
+        ...combat,
+        status: "resolved",
+    };
+}
+export function getCurrentCombatant(combatId) {
+    const combat = getCombat(combatId);
+    if (!combat || combat.status !== "active")
+        return null;
+    return combat.participants[combat.currentTurn]?.characterId || null;
+}

package/dist/tools/constraint.d.ts

@@ -0,0 +1,132 @@
+import type { ConstraintKind, MonotonicDirection, ResourceConstraint } from "../types/index.js";
+/**
+ * Declarative, opt-in, server-enforced invariants on `resources` rows.
+ *
+ * A resource with no declared constraint behaves exactly as it always has --
+ * out-of-bounds writes are silently clamped by clampValue() in resource.ts.
+ * Declaring a constraint here changes that contract for that one resource
+ * (or set of resources, for 'conserved') only.
+ *
+ * SCOPE NOTE: this layer covers the `resources` table only. Three other
+ * numeric write paths bypass it entirely and are NOT covered:
+ *   - factions.resources (JSON blob; see modifyFactionResource/setFactionResource
+ *     in src/tools/faction.ts -- no bounds, no history, silently deletes an
+ *     entry when it hits <= 0)
+ *   - characters.attributes (arbitrary numeric JSON, unvalidated)
+ *   - relationships.value (its own separate system)
+ * A game author who needs a server-enforced invariant on a quantity must
+ * model that quantity as a `resources` row, not one of the above.
+ *
+ * 'conserved' is fully enforced: a resource that is a member of a declared
+ * 'conserved' constraint can no longer be written directly through
+ * update_resource_value (see checkResourceConstraints() below) -- it must go
+ * through transferResourceValue() in resource.ts, which moves value between
+ * exactly two members of the same set atomically. See the comment on
+ * transferResourceValue() for why an explicit transfer, rather than a
+ * balanced multi-resource write, was chosen.
+ */
+/** Absolute tolerance for floating-point sum comparisons on 'conserved'
+ * constraints. IEEE 754 doubles cannot represent values like 0.1 exactly,
+ * so repeated addition/subtraction across many transfers can drift by a
+ * few ULPs. This is large enough to absorb that drift over realistic
+ * transfer volumes while still catching an actual logic bug (which would
+ * typically desync the sum by a whole `amount`, not a fraction of one). */
+export declare const CONSERVED_SUM_EPSILON = 0.000001;
+export declare class ConstraintViolationError extends Error {
+    readonly constraintKind: ConstraintKind;
+    readonly resourceId: string;
+    constructor(constraintKind: ConstraintKind, resourceId: string, message: string);
+}
+/**
+ * Declare a 'bounded' constraint: the resource's value must stay within its
+ * existing minValue/maxValue (set via create_resource/update_resource).
+ * Once declared, out-of-bounds writes through updateResourceValue() are
+ * REJECTED instead of silently clamped -- see checkResourceConstraints().
+ */
+export declare function declareBoundedConstraint(params: {
+    gameId: string;
+    resourceId: string;
+}): ResourceConstraint;
+/**
+ * Declare a 'monotonic' constraint: the resource's value may only move in
+ * the given direction. 'increasing' means it may never decrease;
+ * 'decreasing' means it may never increase. Holding steady is always
+ * allowed.
+ */
+export declare function declareMonotonicConstraint(params: {
+    gameId: string;
+    resourceId: string;
+    direction: MonotonicDirection;
+}): ResourceConstraint;
+/**
+ * Register a 'conserved' constraint: a set of resources that must always
+ * sum to a fixed total.
+ *
+ * Validation performed here, all rejecting rather than silently coercing:
+ *   - at least two distinct resources
+ *   - every resourceId must exist
+ *   - `total` must be a finite number
+ *   - no resource may already belong to another 'conserved' constraint --
+ *     a resource can be a member of at most one conserved set at a time, so
+ *     that transferResourceValue() (resource.ts) never has to guess which
+ *     set a transfer touching that resource is supposed to preserve
+ *   - the members' CURRENT values must already sum to `total`. This
+ *     constraint records an existing invariant, it does not establish one --
+ *     if the values don't already sum to `total`, that's almost always a
+ *     caller mistake (wrong total, forgot a member), and silently rewriting
+ *     resource values to make it true would hide that mistake.
+ *
+ * A resource may still separately hold a 'bounded' and/or 'monotonic'
+ * constraint alongside 'conserved' -- those are orthogonal and both remain
+ * enforced during transfers (see transferResourceValue()).
+ */
+export declare function declareConservedConstraint(params: {
+    gameId: string;
+    resourceIds: string[];
+    total: number;
+}): ResourceConstraint;
+/** List constraints for a game, optionally filtered to ones governing a given resource. */
+export declare function listConstraints(gameId: string, resourceId?: string): ResourceConstraint[];
+/** All constraints (of any kind) that govern the given resource. */
+export declare function getConstraintsForResource(resourceId: string): ResourceConstraint[];
+/** Remove a constraint by id. Returns true if a row was deleted. */
+export declare function removeConstraint(id: string): boolean;
+/**
+ * Check whether an intended value change for a single resource would
+ * violate any 'bounded' or 'monotonic' constraint declared on it. Throws
+ * ConstraintViolationError on violation; returns void otherwise. Shared by
+ * checkResourceConstraints() (the single-resource write path) and
+ * transferResourceValue() (resource.ts; the two-resource conserved-transfer
+ * path) -- both paths must respect 'bounded'/'monotonic' the same way.
+ * Deliberately does not look at 'conserved' constraints; callers decide
+ * separately what to do about those (see checkResourceConstraints() below
+ * and transferResourceValue()).
+ */
+export declare function checkBoundedAndMonotonicConstraints(resourceId: string, previousValue: number, intendedValue: number, bounds: {
+    minValue: number | null;
+    maxValue: number | null;
+}): void;
+/**
+ * Check whether an intended value change for a single resource would
+ * violate any constraint declared on it. Throws ConstraintViolationError on
+ * violation; returns void otherwise. Called from updateResourceValue() in
+ * resource.ts before the row is written.
+ *
+ * 'conserved' is handled specially here: ANY direct single-resource write to
+ * a conserved member is rejected, unconditionally, regardless of whether the
+ * particular delta would happen to preserve the total. The server cannot
+ * know where update_resource_value's counterpart delta should come from --
+ * writing one member without atomically adjusting another would silently
+ * break the set's invariant, which is exactly the failure this constraint
+ * exists to prevent. Use transfer_resource_value (transferResourceValue() in
+ * resource.ts) instead, which moves value between two members of the same
+ * set atomically.
+ */
+export declare function checkResourceConstraints(resourceId: string, previousValue: number, intendedValue: number, bounds: {
+    minValue: number | null;
+    maxValue: number | null;
+}): void;
+/** All conserved constraints (of kind 'conserved') governing a resource,
+ * i.e. zero or one (declareConservedConstraint() rejects overlapping
+ * conserved membership, so a resource can belong to at most one). */
+export declare function getConservedConstraintFor(resourceId: string): ResourceConstraint | null;