rpg-engine 0.0.0-stage → 0.1.0

package/dist/commands/advance.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+import { type TimePassed } from "./game-advance.ts";
+export declare const advance: import("../core/registry.ts").Command<z.ZodObject<{
+    by: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodString>;
+    why: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, TimePassed>;

package/dist/commands/advance.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { changeState, requireCampaign } from "../campaign/index.js";
+import { appendLogEntry } from "../core/log.js";
+import { defineCommand } from "../core/registry.js";
+import { addDuration, formatDuration, formatGameDate, lastGameDay, minutesBetween, readDuration, readGameDate } from "../time/index.js";
+import { nextAfter, passedLines, passTime, unreadNotes } from "./game-advance.js";
+import { dueEvents, dueText, isDated, plannedEvents } from "./game-events.js";
+import { newDatedLogEntry, presentDate } from "./game-time.js";
+import { campaignWorld } from "./game-world.js";
+export const advance = defineCommand({
+    name: "advance",
+    description: "Let time pass in the story, whenever it does, before you narrate it: by a duration or to a later game date. "
+        + "At the first scene, set the date the game starts on with to, at the scene's hour. Time never goes back. "
+        + "It stops at the first planned event that comes due and says how to play it; on a new day, it lists the events' clocks to move. "
+        + 'Example: by 8h, why "a night at the inn".',
+    group: "game",
+    input: z.object({
+        by: z.string().optional().describe("how much time passes, in days, hours and minutes: 10m, 4h, 1d 6h"),
+        to: z.string().optional().describe("the game date to reach, such as day 3, 06:00 (day 3 alone is its midnight); the first one sets when play starts, such as day 1, 18:00"),
+        why: z.string().optional().describe("what the time is spent on"),
+    }),
+    run(input, context) {
+        const root = requireCampaign(context.folder);
+        const request = readRequest(input);
+        const now = presentDate(root);
+        const world = campaignWorld(root, context);
+        const why = input.why?.trim() === "" ? undefined : input.why;
+        if (now === undefined) {
+            if ("by" in request) {
+                throw new Error('The game has no date yet: set the date it starts on with to, such as to "day 1, 18:00".');
+            }
+            const start = formatGameDate(request.to);
+            changeState(root, { date: start });
+            appendLogEntry(root, newDatedLogEntry(root, context, "time-advanced", "public", { to: start, why }));
+            const next = nextAfter(plannedEvents(world).filter(isDated), request.to);
+            return { to: start, passed: 0, wanted: 0, due: [], stillDue: dueEvents(world, request.to).map(dueText), next, ended: [], newDays: 0, clocks: [], newDayPart: "", ...unreadNotes(world) };
+        }
+        const end = "by" in request ? addDuration(now, request.by) : request.to;
+        if (end.day > lastGameDay) {
+            throw new Error(`${input.by} would go past day ${lastGameDay}, the last game date the engine counts: let less time pass.`);
+        }
+        const wanted = minutesBetween(now, end);
+        if (wanted < 0) {
+            throw new Error(`${formatGameDate(end)} is before now, ${formatGameDate(now)}: time never goes back.`);
+        }
+        return passTime(root, context, world, now, wanted, why, input.by ?? input.to ?? "");
+    },
+    format(result) {
+        const rest = result.wanted - result.passed;
+        const then = rest > 0 ? ` Then advance the other ${formatDuration(rest)}, if they are still doing what they were.` : "";
+        return [movedLine(result, rest), ...passedLines(result, then)].filter((line) => line !== "").join("\n");
+    },
+});
+function readRequest(input) {
+    if ((input.by === undefined) === (input.to === undefined)) {
+        throw new Error("Give one of by (how much time passes, such as 8h or 1d 6h) or to (the game date to reach, such as day 3, 06:00).");
+    }
+    if (input.by !== undefined) {
+        const minutes = readDuration(input.by);
+        if (minutes === undefined) {
+            throw new Error(`"${input.by}" is not a duration: write days, hours and minutes in this order, such as 10m, 4h or 1d 6h.`);
+        }
+        return { by: minutes };
+    }
+    const date = readGameDate(input.to);
+    if (date === undefined) {
+        throw new Error(`"${input.to}" is not a game date: write it as day 3, 06:00, or day 3.`);
+    }
+    return { to: date };
+}
+/** The first line: where time went, and where it stopped short of what was asked. */
+function movedLine(result, rest) {
+    if (result.from === undefined) {
+        return `The game starts on ${result.to}.`;
+    }
+    if (result.passed === 0) {
+        return `Nothing changed: it is already ${result.to}.`;
+    }
+    return `${result.from} → ${result.to}${rest > 0 ? `: stopped after ${formatDuration(result.passed)} of ${formatDuration(result.wanted)}` : ""}.`;
+}

package/dist/commands/ask.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+type InWords = {
+    kind: "unanswered" | "unavailable" | "absent" | "physical";
+    asked: string;
+};
+type AskResult = {
+    kind: "roll";
+    id: string;
+    who: string;
+    check: string;
+    text: string;
+    total: number;
+} | {
+    kind: "changed";
+} | {
+    kind: "chose";
+    answer: string;
+} | {
+    kind: "said";
+    words: string;
+} | {
+    kind: "moved";
+    text: string;
+} | {
+    kind: "stays";
+} | InWords;
+export declare const ask: import("../core/registry.ts").Command<z.ZodObject<{
+    question: z.ZodString;
+    options: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    who: z.ZodOptional<z.ZodString>;
+    square: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, AskResult>;
+export {};

package/dist/commands/ask.js

@@ -0,0 +1,280 @@
+import { z } from "zod";
+import { readSettings, requireCampaign } from "../campaign/index.js";
+import { appendLogEntry } from "../core/log.js";
+import { defineCommand } from "../core/registry.js";
+import { DiceError, parseNotation, rollDice } from "../dice/index.js";
+import { closedSquare, readSquare } from "../grid/index.js";
+import { findPage, loadWorld, locate } from "../pages/index.js";
+import { placeGrid } from "./game-grids.js";
+import { newDatedLogEntry } from "./game-time.js";
+import { campaignSystem } from "./game-world.js";
+import { placeOnMap } from "./move.js";
+import { hasNames, namesAsZero, rollerOf, withSheetValues } from "./roll.js";
+// The words of the buttons, in the campaign's language; English for the others (ASK-7).
+const buttonWords = {
+    en: { roll: "Roll", change: "Change my mind", choice: "Choice", square: "Move" },
+    it: { roll: "Tiro", change: "Cambio idea", choice: "Scelta", square: "Movimento" },
+};
+// A list, or one text, as an MCP client may send it.
+const textList = z.union([z.string(), z.array(z.string())]);
+export const ask = defineCommand({
+    name: "ask",
+    description: "Ask the player with buttons: every roll of the player's character, and every choice that is truly theirs to make. "
+        + "The call returns when the player clicks: for a check, the engine rolls it, logs it as the player's roll, and gives you the result. "
+        + "For a roll: the question says what is at stake either way, in about 100 characters (apps may cut it); give the checks that fit, each with its dice, "
+        + "naming the sheet's numbers by their fields as roll does: the engine works them out, and only then the player's sheet lights that row; the player may also change their mind. "
+        + "In a fight: the attack, then the damage if it hits, each with its own ask; saving throws and rolls to stay alive too. "
+        + "For a choice the rules or the story force (a reaction, a fork): give the answers. Never to offer actions, which are the player's to say, and never for hidden rolls. "
+        + "square, without options, once the player says their character moves on the map of its place but not to which square: the engine moves them to the square the player touches and gives you the way. "
+        + "Write nothing before the call: the question carries what is at stake, and the story goes on after the click. "
+        + 'Example: question "Scavalcare il muro prima della ronda: se fallisci, cadi e ti sentono", options ["Atletica 1d20+athletics", "Acrobazia 1d20+acrobatics"], who Bruna.',
+    group: "game",
+    needsPlayer: true,
+    input: z.object({
+        question: z.string().describe("what is at stake either way, or the choice, in one line, in the player's language"),
+        options: textList.optional().describe("for a roll, the checks that fit with their dice, such as Atletica 1d20+athletics; for a choice, the answers, such as Sì and No; from 1 to 4"),
+        who: z.string().optional().describe("for a roll or a square, the player's character, such as Bruna; the only one there is, if left out"),
+        square: z.boolean().optional().describe("true to ask where the player's character moves on its place's map"),
+    }),
+    async run(input, context) {
+        const root = requireCampaign(context.folder);
+        if (context.player === undefined && context.page === undefined) {
+            throw new Error("The player cannot be asked with buttons here: ask them in words, without a word about buttons, and stop.");
+        }
+        const question = input.question.trim();
+        const words = buttonWords[(readSettings(root).language ?? "en").split("-")[0]] ?? buttonWords.en;
+        if (question === "") {
+            throw new Error("Give the question: for a roll, what is at stake either way; for a choice, what the player chooses.");
+        }
+        if (input.square === true) {
+            if (input.options !== undefined) {
+                throw new Error("Give square without options: the player touches a square of the map, and the engine moves their character there.");
+            }
+            return squareChosen(root, context, question, input.who, words);
+        }
+        const options = readOptions(input.options ?? []);
+        const checks = options.filter((option) => option.notation !== undefined);
+        // One answer alone is no choice: a roll whose dice are not at the end would become one, and nothing would be rolled (ASK-2, D-266).
+        if (checks.length === 0 && options.length === 1) {
+            throw new Error(`"${options[0].label}" alone is no choice: a roll ends with its dice, such as Danni radianti 1d8; a choice gives two answers or more.`);
+        }
+        if (checks.length === 0) {
+            return answer(root, context, question, options, words);
+        }
+        if (checks.length < options.length) {
+            throw new Error(`Give every check its dice, such as Atletica 1d20+5; for a choice, give only the answers, such as Sì and No. A roll already has its button to change one's mind (${words.change}): leave out an answer such as No.`);
+        }
+        const who = playerCharacter(loadWorld(root), input.who);
+        const worked = sheetChecks(root, context, checks, who);
+        // The player rolls their own dice: a roll is asked in words, and they tell the values (ASK-8).
+        if (readSettings(root).dice === "physical") {
+            return { kind: "physical", asked: askedText(question, "checks", worked) };
+        }
+        return rollChosen(root, context, question, worked, who, words);
+    },
+    format(result) {
+        switch (result.kind) {
+            case "roll":
+                return `${result.id} ${result.who}, ${result.check}: ${result.text}, rolled by the player. Tell the outcome in the story, with the roll in brackets right after the moment it decides.`;
+            case "changed":
+                return "The player changed their mind: no roll. Ask what they do instead, and stop.";
+            case "chose":
+                return `The player chose: ${result.answer}.`;
+            case "said":
+                return `The player answered in their own words, without a button: «${result.words}». Take it as what they do, as if they had written it in the chat; nothing was rolled.`;
+            case "moved":
+                return `The player chose where to go: ${result.text}`;
+            case "stays":
+                return "The player changed their mind: their character does not move. Ask what they do instead, and stop.";
+            case "unavailable":
+                return `The player saw no buttons: ask them in words what the call held, which they have not seen: ${result.asked}. No word about buttons; then stop. From now on, always in words.`;
+            case "absent":
+                return `The player has no buttons open now: ask them in words this time what the call held, which they have not seen: ${result.asked}. No word about buttons; then stop.`;
+            case "physical":
+                return `The player rolls their own dice: tell first in the story what happened before this roll, such as the blow that calls for it, then ask it in words, with what is at stake and the checks: ${result.asked}. Then stop; they will tell the values.`;
+            default:
+                return `No answer from the buttons: ask the player in words what the call held: ${result.asked}. Then stop.`;
+        }
+    },
+});
+/** The buttons of a roll: the checks and a change of mind (ASK-3, ASK-4). The chosen check is rolled with the engine's dice and logged as the player's roll. */
+async function rollChosen(root, context, question, checks, who, words) {
+    const labels = [...checks.map((check) => `${words.roll}: ${check.label} (${check.notation})`), words.change];
+    const chosen = await choose(context, question, words.roll, labels, { who, fields: [...checks.map((check) => check.field ?? null), null] });
+    const asked = askedText(question, "checks", checks);
+    // A call the user stopped logs nothing (ASK-9).
+    if (chosen === "absent" || context.signal?.aborted === true) {
+        return { kind: chosen === "absent" ? "absent" : "unanswered", asked };
+    }
+    if (isSaid(chosen)) {
+        return said(root, context, question, labels, chosen);
+    }
+    if (chosen === "unavailable") {
+        logAnswer(root, context, question, labels, undefined);
+        return { kind: "unavailable", asked };
+    }
+    const check = chosen === undefined ? undefined : checks[chosen];
+    if (check?.notation === undefined) {
+        logAnswer(root, context, question, labels, chosen === checks.length ? words.change : undefined);
+        return chosen === checks.length ? { kind: "changed" } : { kind: "unanswered", asked };
+    }
+    const diceRoll = rollDice(check.notation, { random: context.random });
+    const data = { notation: diceRoll.notation, total: diceRoll.total, result: diceRoll.text, why: `${check.label}: ${question}`, check: check.label, who, physical: false, dice: diceRoll.dice };
+    const entry = newDatedLogEntry(root, { ...context, actor: "player" }, "roll", "public", data);
+    appendLogEntry(root, entry);
+    return { kind: "roll", id: entry.id, who, check: check.label, text: diceRoll.text, total: diceRoll.total };
+}
+/**
+ * Where the player's character moves on the map of its place (ASK-11): only the page can show the map; the square touched moves it, as move with at, and the
+ * master gets what move says. Refused when it stands on no map.
+ */
+async function squareChosen(root, context, question, given, words) {
+    const world = loadWorld(root);
+    const who = playerCharacter(world, given);
+    const { place, map } = standingOn(world, who);
+    if (place === undefined || map === undefined) {
+        throw new Error(`${who} stands in no place with a map: ask in words where they go, and stop.`);
+    }
+    // Without a page no map is in sight: the master asks where in the story's words, and puts them on the square that fits.
+    const asked = `${question} (where their character goes in ${place.name}, in the story's words; then move them with move and at to the square that fits)`;
+    const chosen = context.page?.chooseSquare === undefined ? "absent" : await context.page.chooseSquare(question, words.square, words.change, context.signal);
+    // A call the user stopped logs nothing (ASK-9).
+    if (chosen === "absent" || context.signal?.aborted === true) {
+        return { kind: chosen === "absent" ? "absent" : "unanswered", asked };
+    }
+    if (isSaid(chosen)) {
+        return said(root, context, question, [words.change], chosen);
+    }
+    if (chosen === undefined || chosen === 0) {
+        logAnswer(root, context, question, [words.change], chosen === 0 ? words.change : undefined);
+        return chosen === 0 ? { kind: "stays" } : { kind: "unanswered", asked };
+    }
+    // The world may have changed while the player chose: the square counts only on the map they were shown, as it is now.
+    const now = standingOn(loadWorld(root), who);
+    if (now.place?.name !== place.name || now.map === undefined) {
+        throw new Error(`${who} is no longer in ${place.name}, on whose map the player chose ${chosen.square}: nothing moved. Ask again where they go, and stop.`);
+    }
+    const square = readSquare(chosen.square);
+    const closed = square === undefined ? `${chosen.square} is no square of the map` : closedSquare(now.map.grid, square);
+    // A square no one stands on, as one a hidden thing blocks, moves no one and logs nothing.
+    if (closed !== undefined) {
+        throw new Error(`The player chose ${chosen.square}, but ${closed}: ${who} cannot stand there, and nothing moved. Ask again where they go, and stop.`);
+    }
+    logAnswer(root, context, question, [words.change], chosen.square);
+    return { kind: "moved", text: placeOnMap(root, context, who, chosen.square) };
+}
+/** The place the character is right in, with its map, as the world is. */
+function standingOn(world, who) {
+    const page = findPage(world, who);
+    const place = page === undefined ? undefined : locate(world, page).chain[0];
+    return place === undefined ? {} : { place, map: placeGrid(place) };
+}
+/** The buttons of a forced choice: the answers as given (ASK-5). */
+async function answer(root, context, question, options, words) {
+    const labels = options.map((option) => option.label);
+    const chosen = await choose(context, question, words.choice, labels);
+    const asked = askedText(question, "answers", options);
+    if (chosen === "absent" || context.signal?.aborted === true) {
+        return { kind: chosen === "absent" ? "absent" : "unanswered", asked };
+    }
+    if (isSaid(chosen)) {
+        return said(root, context, question, labels, chosen);
+    }
+    const answered = chosen === undefined || chosen === "unavailable" ? undefined : labels[chosen];
+    logAnswer(root, context, question, labels, answered);
+    if (chosen === "unavailable") {
+        return { kind: "unavailable", asked };
+    }
+    return answered === undefined ? { kind: "unanswered", asked } : { kind: "chose", answer: answered };
+}
+/** The player's own words in place of a button (ASK-10): no roll, a public line with them as the answer, and the master takes them as what the player does. */
+function said(root, context, question, labels, words) {
+    logAnswer(root, context, question, labels, words.said);
+    return { kind: "said", words: words.said };
+}
+function isSaid(chosen) {
+    return typeof chosen === "object" && chosen !== null && "said" in chosen;
+}
+/** "Scavalcare il muro… (the checks: Atletica 1d20+5, Acrobazia 1d20-1)": the call as the master gave it, to ask in words. */
+function askedText(question, what, options) {
+    return `${question} (the ${what}: ${options.map((option) => (option.notation === undefined ? option.label : `${option.label} ${option.notation}`)).join(", ")})`;
+}
+/**
+ * The player's answer: on the dashboard's page while one is open, else in the host's form, if it shows one (ASK-1, D-279). A form that does not show, while
+ * the dashboard runs, is only absent this time: a page may open.
+ */
+async function choose(context, question, title, labels, rows) {
+    const onPage = context.page === undefined ? "absent" : await context.page.choose(question, title, labels, context.signal, rows);
+    if (onPage !== "absent" || context.player === undefined) {
+        return onPage;
+    }
+    const inForm = await context.player.choose(question, title, labels, context.signal);
+    return inForm === "unavailable" && context.page !== undefined ? "absent" : inForm;
+}
+/** A public line for what the player answered, or that no one did (ASK-6); a roll has its own line instead. */
+function logAnswer(root, context, question, labels, answered) {
+    appendLogEntry(root, newDatedLogEntry(root, { ...context, actor: answered === undefined ? context.actor : "player" }, "asked", "public", { question, options: labels, answer: answered ?? null }));
+}
+/** The options as buttons: a check ends with its dice, such as Atletica 1d20+5; anything else is an answer (ASK-2). */
+function readOptions(given) {
+    const options = (typeof given === "string" ? [given] : given).map((text) => text.trim()).filter((text) => text !== "").map(readOption);
+    if (options.length === 0 || options.length > 4) {
+        throw new Error(`Give from 1 to 4 options; ${options.length === 0 ? "none was given" : `${options.length} were given`}.`);
+    }
+    const repeated = options.find((option, index) => options.findIndex((other) => other.label.toLowerCase() === option.label.toLowerCase()) !== index);
+    if (repeated !== undefined) {
+        throw new Error(`${repeated.label} is given twice: each button needs its own words.`);
+    }
+    return options;
+}
+function readOption(text) {
+    // The dice from the first word that is a die, so that 1d20+athletics - 1 and 1d20 + athletics are dice too; else the last word.
+    const spaced = /^(.+?)\s+(\d*d(?:\d+|%|F)\S*(?:\s*[+-]\s*\S+)*)$/i.exec(text);
+    const last = /^(.+?)\s+(\S+)$/.exec(text);
+    const match = [spaced, last].find((candidate) => candidate !== null && isDice(namesAsZero(candidate[2])));
+    return match === undefined || match === null ? { label: text } : { label: match[1].trim(), notation: match[2] };
+}
+/**
+ * The checks with the numbers of who's sheet their dice name worked out, effects included, as roll does (ASK-12, DAT-8); each with the field it rolls when it
+ * names one alone, whose row of the sheet the page lights.
+ */
+function sheetChecks(root, context, checks, who) {
+    const named = checks.filter((check) => check.notation !== undefined && hasNames(check.notation));
+    const roller = named.length === 0 ? undefined : rollerOf(root, context, who, true);
+    const system = named.length === 0 ? undefined : campaignSystem(root, context);
+    return checks.map((check) => {
+        if (!named.includes(check) || check.notation === undefined) {
+            return check;
+        }
+        const { notation, taken } = withSheetValues(check.notation, roller, who, system);
+        const fields = Object.keys(taken);
+        return { ...check, notation: notation.replace(/\s+/g, ""), ...(fields.length === 1 ? { field: fields[0] } : {}) };
+    });
+}
+/** Whether a text is dice to roll, such as 1d20+5 or 2d20kh1+3: a number alone is not. */
+function isDice(text) {
+    try {
+        return parseNotation(text).some((term) => term.kind === "dice");
+    }
+    catch (error) {
+        if (error instanceof DiceError) {
+            return false;
+        }
+        throw error;
+    }
+}
+/** The player's character the roll belongs to: the one named, or the only one there is (ASK-2). */
+function playerCharacter(world, who) {
+    const players = world.pages.filter((page) => page.type === "character" && page.fields.role === "pc");
+    if (who === undefined || who.trim() === "") {
+        if (players.length !== 1) {
+            throw new Error(players.length === 0 ? "There is no player character yet (role pc): ask rolls only theirs." : `Give who rolls: ${players.map((page) => page.name).join(" or ")}.`);
+        }
+        return players[0].name;
+    }
+    const page = findPage(world, who);
+    if (page === undefined || !players.includes(page)) {
+        throw new Error(`${who.trim()} is not the player's character (role pc): ask rolls only theirs; roll for the others with roll.`);
+    }
+    return page.name;
+}

package/dist/commands/change.d.ts

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { fireEvents } from "./game-events.ts";
+export declare const change: import("../core/registry.ts").Command<z.ZodObject<{
+    page: z.ZodOptional<z.ZodString>;
+    field: z.ZodOptional<z.ZodString>;
+    by: z.ZodOptional<z.ZodUnion<readonly [z.ZodPreprocess<z.ZodNumber, unknown>, z.ZodString]>>;
+    spend: z.ZodOptional<z.ZodUnion<readonly [z.ZodPreprocess<z.ZodNumber, unknown>, z.ZodString]>>;
+    to: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    why: z.ZodOptional<z.ZodString>;
+    recipe: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    recipe: string;
+    system: string;
+    outcomes: RecipeOutcome[];
+    rules: string[];
+} | {
+    problems: string[];
+    page: string;
+    field: string;
+    before: string;
+    after: string;
+    total?: string;
+    /** "in Forma d'orso; at max; again as Lupo": the effect it changed on, the limit it reached, the base whose value the page reads again. */
+    note: string;
+    effect?: string;
+    again?: string;
+    changed: boolean;
+    due: ReturnType<typeof fireEvents>["due"];
+    followers: string[];
+    keepers: string[];
+    thresholds: string[];
+    /** What the change may break that someone keeps alive, and what shields the counter it lowered (EFF-14, DAT-14). */
+    reminders: string[];
+}>;
+/** What a step did to a counter or to money. */
+interface StepOutcome {
+    page: string;
+    field: string;
+    before: string;
+    after: string;
+    total?: string;
+    /** "in Forma d'orso; at max; again as Lupo": the effect it changed on, the limit it reached, the base whose value the page reads again. */
+    note: string;
+    effect?: string;
+    again?: string;
+    changed: boolean;
+    due: ReturnType<typeof fireEvents>["due"];
+    followers: string[];
+    keepers: string[];
+    thresholds: string[];
+    /** What the change may break that someone keeps alive, and what shields the counter it lowered (EFF-14, DAT-14). */
+    reminders: string[];
+}
+/**
+ * What a recipe did to a page: the effects it ended, the steps it wrote, what it leaves to the player or, for a companion, to the master (D-206), and the
+ * counters it leaves to the master.
+ */
+interface RecipeOutcome {
+    page: string;
+    pc: boolean;
+    ended: string[];
+    steps: StepOutcome[];
+    choices: string[];
+    notBroughtBack: string[];
+    kept: string[];
+    /** The effects without an end still on the page, which a rest may ask something of (EFF-15). */
+    resting: string;
+}
+export {};