Floating QoL panel, stat controls & variable tools for Degrees of Lewdity
// ==UserScript==
// @name DoL Companion Panel
// @namespace https://github.com/Zenix-Al/DoL-Companion-Panel
// @version 3.1.0
// @description Floating QoL panel, stat controls & variable tools for Degrees of Lewdity
// @author Zenix-Al
// @match https://vanilla.dolmods.net/*
// @match https://dolp.dolmods.net/*
// @match https://*.dolmods.net/*
// @match file:///*.html
// @match file:///*.htm
// @icon https://f95zone.to/data/avatars/l/1963/1963870.jpg
// @run-at document-idle
// @grant unsafeWindow
// @license GPL-3.0-or-later
// ==/UserScript==
// ------------------------------------------------------------
// Built on 2026-09-08 23:36:55 UTC -- AUTO-GENERATED, edit from /src and rebuild
// Build mode: release
// Artifact: greasyfork
// Logs: debugLog call sites removed
// ------------------------------------------------------------
(() => {
// src/ui/constants.js
var SHADOW_HOST_ID = "dol-cheatplus-host";
var CHEAT_ROOT_ID = "cheat";
// src/core/logger.js
var LS_DEBUG_KEY = "CheatPlus:debug";
var debugEnabled = null;
function isDebugEnabled() {
try {
if (true) return Boolean(false);
} catch (e) {
}
if (debugEnabled != null) return Boolean(debugEnabled);
try {
return localStorage.getItem(LS_DEBUG_KEY) === "1";
} catch (e) {
}
return false;
}
function debugLog(feature, msg, { data = null, level = "log" } = {}) {
if (!isDebugEnabled()) return;
const logMethod = console[level] || console.log;
const style = level === "warn" ? "color: orange;" : level === "error" ? "color: red;" : "";
try {
console.groupCollapsed(`%c[CheatPlus][${feature}] ${msg}`, style);
logMethod(msg);
if (data !== null && typeof data !== "undefined") logMethod(data);
} catch (e) {
try {
logMethod(`[CheatPlus][${feature}] ${msg}`);
if (data) logMethod(data);
} catch (err) {
}
} finally {
try {
console.groupEnd();
} catch (e) {
}
}
}
var logger_default = debugLog;
// src/core/safe-exec.js
function safeCall(label, fn, { onError = null } = {}) {
try {
return fn();
} catch (err) {
if (typeof onError === "function") {
onError(err);
} else {
console.warn(`[CheatPlus] ${label}`, err);
}
return void 0;
}
}
// src/core/actions/dispatcher.js
var dispatcherStore = {
handlers: /* @__PURE__ */ new Map(),
onError: null
};
function getStore() {
return dispatcherStore;
}
function register(key, handler) {
if (typeof key !== "string" || !key) {
logger_default("dispatcher", "register: key must be a non-empty string.", { level: "warn" });
return;
}
if (typeof handler !== "function") {
logger_default("dispatcher", `register: handler for "${key}" is not a function.`, {
level: "warn"
});
return;
}
logger_default("dispatcher", `Registered action: ${key}`);
getStore().handlers.set(key, handler);
}
function dispatch(key, context) {
const store2 = getStore();
const handler = store2.handlers.get(key);
if (!handler) {
logger_default("dispatcher", `No handler registered for action: "${key}"`, { level: "warn" });
return;
}
try {
logger_default("dispatcher", `Dispatching action: ${key}`);
return handler(context);
} catch (err) {
logger_default("dispatcher", `Handler error for action: ${key}`, { data: err, level: "error" });
if (typeof store2.onError === "function") {
try {
store2.onError(key, err);
} catch (_) {
}
}
}
}
function setErrorHook(fn) {
if (typeof fn !== "function") return;
getStore().onError = fn;
}
// src/ui/theme/style-registry.js
var registry = { shadow: [], document: [] };
function getRegistry() {
return registry;
}
function registerSheet(cssText, { target = "shadow" } = {}) {
const reg = getRegistry();
if (target === "shadow" || target === "both") {
if (!reg.shadow.includes(cssText)) reg.shadow.push(cssText);
}
if (target === "document" || target === "both") {
if (!reg.document.includes(cssText)) reg.document.push(cssText);
}
}
var appliedShadowRoots = /* @__PURE__ */ new WeakSet();
function applyToShadow(shadowRoot2) {
if (!shadowRoot2) return;
if (appliedShadowRoots.has(shadowRoot2)) return;
appliedShadowRoots.add(shadowRoot2);
const reg = getRegistry();
reg.shadow.forEach((cssText) => {
const style = document.createElement("style");
style.textContent = cssText;
shadowRoot2.appendChild(style);
});
}
// src/core/state.js
var store = {
state: null,
subscribers: /* @__PURE__ */ new Map()
};
var initialState = () => ({
modal: {
open: false,
isDelete: false,
isCheatPressed: false
},
runtime: {
isLoad: false,
clickCounter: 0,
curDate: 0,
errorFunctions: 0,
progressFunctions: 0,
totalFunctions: 0,
extraNotif: false,
reactivatingToggles: false,
isTestingAllFunction: false,
pcPregnant: 0,
totalNpcPregnant: 0
}
});
function getStore2() {
if (!store.state) {
store.state = initialState();
}
return store;
}
function getByPath(obj, path7) {
return path7.split(".").reduce((cur, key) => cur != null ? cur[key] : void 0, obj);
}
function setByPath(obj, path7, value) {
const keys = path7.split(".");
const last = keys.pop();
const parent = keys.reduce((cur, key) => {
if (cur[key] == null) cur[key] = {};
return cur[key];
}, obj);
parent[last] = value;
}
function get(path7) {
return getByPath(getStore2().state, path7);
}
function set(path7, value) {
const store2 = getStore2();
const oldValue = getByPath(store2.state, path7);
if (oldValue === value) return;
setByPath(store2.state, path7, value);
const callbacks = store2.subscribers.get(path7);
if (callbacks) {
callbacks.forEach((cb) => {
try {
cb(value, oldValue, path7);
} catch (e) {
}
});
}
}
// src/ui/shell/dom-query.js
var shadowHost = null;
var shadowRoot = null;
var quicklink = null;
var statlink = null;
var misclink = null;
var quickcontent = null;
var statscontent = null;
var misccontent = null;
var toastContainer = null;
var modal = null;
var modalContentContainer = null;
var cheat = null;
function getUiRoot() {
return shadowRoot || document;
}
function byUiId(id) {
if (shadowRoot) {
if (typeof shadowRoot.getElementById === "function") {
const el2 = shadowRoot.getElementById(id);
if (el2) return el2;
}
const el = shadowRoot.querySelector("#" + id);
if (el) return el;
}
return document.getElementById(id);
}
function ensureShadowRoot() {
if (shadowRoot) return shadowRoot;
if (!document.body) return null;
shadowHost = document.getElementById(SHADOW_HOST_ID);
if (!shadowHost) {
shadowHost = document.createElement("div");
shadowHost.id = SHADOW_HOST_ID;
document.body.appendChild(shadowHost);
try {
logger_default("ui", "ensureShadowRoot: created shadow host", { data: { id: SHADOW_HOST_ID } });
} catch (e) {
}
}
shadowRoot = shadowHost.shadowRoot || shadowHost.attachShadow({ mode: "open" });
try {
logger_default("ui", "ensureShadowRoot: shadowRoot attached", {
data: { hasShadowRoot: !!shadowRoot }
});
} catch (e) {
}
return shadowRoot;
}
function refreshUiRefs() {
quicklink = byUiId("quick-link");
statlink = byUiId("stats-link");
misclink = byUiId("misc-link");
quickcontent = byUiId("quick-content");
statscontent = byUiId("stats-content");
misccontent = byUiId("misc-content");
toastContainer = byUiId("toastContainer");
modal = byUiId("modal");
modalContentContainer = byUiId("modal-content-container");
cheat = byUiId("cheat");
try {
logger_default("ui", "refreshUiRefs", {
data: {
cheat: !!cheat,
modal: !!modal,
modalContentContainer: !!modalContentContainer
}
});
} catch (e) {
}
}
refreshUiRefs();
function getUiRefs() {
refreshUiRefs();
return {
quicklink,
quickcontent,
statlink,
statscontent,
misclink,
misccontent
};
}
// src/ui/shell/layout.js
var modalTemplate = {
tag: "div",
id: "modal",
class: "modal",
children: [
{
tag: "div",
class: "modal-content",
children: [
{
tag: "div",
class: "navbar",
children: [
{ tag: "div", id: "quick-link", class: "nav-link gold", text: "Quick" },
{ tag: "div", id: "stats-link", class: "nav-link", text: "Stat" },
{ tag: "div", id: "misc-link", class: "nav-link", text: "Misc" },
{ tag: "div", id: "close-modal-top", class: "close nav-link", text: "\xD7" }
]
},
{
tag: "div",
id: "modal-content-container",
children: [
{ tag: "div", id: "quick-content", class: "cheat-content active" },
{ tag: "div", id: "stats-content", class: "cheat-content" },
{ tag: "div", id: "misc-content", class: "cheat-content" }
]
},
{
tag: "div",
class: "navbar",
children: [{ tag: "div", id: "close-modal-bottom", class: "close nav-link", text: "\xD7" }]
}
]
}
]
};
var layoutTemplate = {
tag: "div",
id: "cheat",
children: [
{
tag: "div",
id: "floating-button",
children: [
{ tag: "button", id: "cheat-history-backwards", text: "\u2190", hidden: true },
{ tag: "button", id: "cheat-history-forwards", text: "\u2192", hidden: true },
{ tag: "button", id: "cheat-sidebar", text: "\u2630", hidden: true },
{ tag: "button", id: "cheat-open", text: "Cheat" }
]
},
{ tag: "div", id: "toastContainer" },
{ tag: "div", id: "effect-layer", class: "hidden" }
// Modal is injected lazily on first open.
]
};
function renderTemplate(template) {
const el = document.createElement(template.tag);
if (template.id) el.id = template.id;
if (template.class) el.className = template.class;
if (template.text) el.textContent = template.text;
if (template.hidden) el.hidden = true;
if (template.children) {
template.children.forEach((child) => el.appendChild(renderTemplate(child)));
}
return el;
}
// src/core/global-bridge.js
function getRuntimeWindow() {
try {
if (typeof unsafeWindow !== "undefined" && unsafeWindow) return unsafeWindow;
} catch (e) {
}
return typeof window !== "undefined" ? window : void 0;
}
// src/ui/shell/modal-hotkey.js
var MODAL_HOTKEY_STORAGE_KEY = "dol-cheatplus-hotkey";
var MODAL_HOTKEY_GUARD_KEY = "__DOL_CP_MODAL_HOTKEY_BOUND__";
var DEFAULT_MODAL_HOTKEY = "ctrl+shift+c";
var toggleModal = null;
function parseHotkey(hotkey) {
const raw = String(hotkey || "").trim().toLowerCase();
if (!raw) return null;
if (raw === "off" || raw === "disabled") return { disabled: true };
const parts = raw.split("+").map((part) => part.trim()).filter(Boolean);
if (!parts.length) return null;
const key = parts[parts.length - 1];
const mods = new Set(parts.slice(0, -1));
return {
key,
ctrl: mods.has("ctrl") || mods.has("control"),
alt: mods.has("alt"),
shift: mods.has("shift")
};
}
function resolveModalHotkey() {
const runtimeWindow2 = getRuntimeWindow();
let configured = DEFAULT_MODAL_HOTKEY;
try {
const saved = runtimeWindow2?.localStorage?.getItem(MODAL_HOTKEY_STORAGE_KEY);
if (saved) configured = saved;
} catch (_) {
}
return parseHotkey(configured);
}
function isEditableTarget(target) {
if (!target) return false;
const tag = String(target.tagName || "").toLowerCase();
return tag === "input" || tag === "textarea" || tag === "select" || target.isContentEditable === true;
}
function matchesHotkey(event, hotkey) {
if (!hotkey || hotkey.disabled) return false;
const key = String(event.key || "").toLowerCase();
return key === hotkey.key && Boolean(event.ctrlKey) === Boolean(hotkey.ctrl) && Boolean(event.altKey) === Boolean(hotkey.alt) && Boolean(event.shiftKey) === Boolean(hotkey.shift);
}
function ensureModalHotkey(toggleFn) {
if (typeof toggleFn === "function") toggleModal = toggleFn;
const runtimeWindow2 = getRuntimeWindow();
if (runtimeWindow2?.[MODAL_HOTKEY_GUARD_KEY]) return;
const onKeydown = (event) => {
if (isEditableTarget(event.target)) return;
if (!matchesHotkey(event, resolveModalHotkey())) return;
event.preventDefault();
if (typeof toggleModal === "function") toggleModal();
};
document.addEventListener("keydown", onKeydown);
if (runtimeWindow2) runtimeWindow2[MODAL_HOTKEY_GUARD_KEY] = true;
}
// src/ui/shell/modal.js
var teardownModalRuntime = null;
function configureModalRuntimeTeardown(teardown) {
teardownModalRuntime = typeof teardown === "function" ? teardown : null;
}
function toggleModalByHotkey() {
if (get("modal.open")) closeModal();
else openModal();
}
function filterSectionRows(sectionEl, query) {
if (!sectionEl) return;
const norm = String(query ?? "").trim().toLowerCase();
const rows = sectionEl.querySelectorAll(".modal-content-padding");
rows.forEach((row) => {
if (row.classList.contains("cp-search-row")) return;
if (!norm) {
row.style.display = "";
return;
}
const haystack = (row.textContent || "").toLowerCase();
row.style.display = haystack.includes(norm) ? "" : "none";
});
}
function attachSectionSearch(sectionEl, title) {
if (!sectionEl || sectionEl.querySelector(".cp-search-row")) return;
const row = document.createElement("div");
row.className = "modal-content-padding cp-search-row";
const input = document.createElement("input");
input.type = "search";
input.className = "cp-search-input";
input.placeholder = `Search ${title}...`;
input.autocomplete = "off";
input.setAttribute("aria-label", `${title} search`);
input.addEventListener("input", () => filterSectionRows(sectionEl, input.value));
row.appendChild(input);
sectionEl.prepend(row);
}
function ensureSectionSearchBars() {
attachSectionSearch(byUiId("quick-content"), "Quick");
attachSectionSearch(byUiId("stats-content"), "Stat");
attachSectionSearch(byUiId("misc-content"), "Misc");
}
function ensureModalInjected() {
if (byUiId("modal")) return;
const root = getUiRoot();
const cheatRoot = byUiId("cheat");
if (!root || !cheatRoot) return;
const modalEl = renderTemplate(modalTemplate);
modalEl.addEventListener("click", (event) => {
const id = event.target?.id;
if (id === "close-modal-top" || id === "close-modal-bottom") {
closeModal();
return;
}
if (id === "quick-link" || id === "stats-link" || id === "misc-link") {
dispatch(id);
}
});
cheatRoot.appendChild(modalEl);
refreshUiRefs();
}
function openModal() {
if (get("modal.open")) return;
ensureModalHotkey(toggleModalByHotkey);
ensureModalInjected();
const modal2 = byUiId("modal");
if (!modal2) return;
modal2.style.display = "block";
set("modal.open", true);
set("modal.isDelete", false);
set("modal.isCheatPressed", false);
dispatch("init_interface");
ensureSectionSearchBars();
dispatch("quick-link");
}
function closeModal() {
if (!get("modal.open")) return;
const modal2 = byUiId("modal");
if (!modal2) return;
void teardownModalRuntime?.();
set("modal.isDelete", true);
modal2.remove();
refreshUiRefs();
set("modal.open", false);
set("modal.isDelete", false);
set("modal.isCheatPressed", false);
}
ensureModalHotkey(toggleModalByHotkey);
// src/ui/shell/floating-controls.js
var rw = getRuntimeWindow();
var FLOATING_POSITION_KEY = "dol-cheatplus-floating-position-v1";
function clamp(value, min, max) {
return Math.min(Math.max(value, min), max);
}
function applyFloatingPosition(floatingButton, x, y) {
if (!floatingButton) return;
const maxX = Math.max(rw.innerWidth - floatingButton.offsetWidth, 0);
const maxY = Math.max(rw.innerHeight - floatingButton.offsetHeight, 0);
const left = clamp(x, 0, maxX);
const top = clamp(y, 0, maxY);
floatingButton.style.left = `${left}px`;
floatingButton.style.top = `${top}px`;
floatingButton.style.right = "auto";
floatingButton.dataset.cpCustomPosition = "1";
floatingButton.classList.add("cp-custom-position");
}
function persistFloatingPosition(x, y) {
try {
rw.localStorage.setItem(FLOATING_POSITION_KEY, JSON.stringify({ x, y }));
} catch (_) {
}
}
function restoreFloatingPosition(floatingButton) {
if (!floatingButton) return;
try {
const raw = rw.localStorage.getItem(FLOATING_POSITION_KEY);
if (!raw) return;
const parsed = JSON.parse(raw);
if (!Number.isFinite(parsed?.x) || !Number.isFinite(parsed?.y)) return;
applyFloatingPosition(floatingButton, parsed.x, parsed.y);
} catch (_) {
}
}
function initFloatingButtonDrag() {
const floatingButton = byUiId("floating-button");
const dragHandle = byUiId("cheat-open");
if (!floatingButton || !dragHandle || floatingButton.dataset.cpDragBound === "1") return;
restoreFloatingPosition(floatingButton);
let startX = 0;
let startY = 0;
let originLeft = 0;
let originTop = 0;
let dragged = false;
const onPointerMove = (event) => {
const dx = event.clientX - startX;
const dy = event.clientY - startY;
if (!dragged && (Math.abs(dx) > 3 || Math.abs(dy) > 3)) dragged = true;
if (!dragged) return;
applyFloatingPosition(floatingButton, originLeft + dx, originTop + dy);
};
const onPointerUp = () => {
rw.removeEventListener("pointermove", onPointerMove);
rw.removeEventListener("pointerup", onPointerUp);
floatingButton.classList.remove("cp-dragging");
if (!dragged) return;
const left = Number.parseFloat(floatingButton.style.left || "0");
const top = Number.parseFloat(floatingButton.style.top || "0");
persistFloatingPosition(left, top);
dragHandle.dataset.cpSuppressNextClick = "1";
};
dragHandle.addEventListener("pointerdown", (event) => {
event.preventDefault();
if (typeof dragHandle.setPointerCapture === "function") {
try {
dragHandle.setPointerCapture(event.pointerId);
} catch (_) {
}
}
startX = event.clientX;
startY = event.clientY;
dragged = false;
const rect = floatingButton.getBoundingClientRect();
originLeft = rect.left;
originTop = rect.top;
floatingButton.classList.add("cp-dragging");
rw.addEventListener("pointermove", onPointerMove);
rw.addEventListener("pointerup", onPointerUp);
});
dragHandle.addEventListener("click", (event) => {
if (dragHandle.dataset.cpSuppressNextClick !== "1") return;
dragHandle.dataset.cpSuppressNextClick = "0";
event.preventDefault();
if (typeof event.stopImmediatePropagation === "function") event.stopImmediatePropagation();
else event.stopPropagation();
});
rw.addEventListener("resize", () => {
if (floatingButton.dataset.cpCustomPosition !== "1") return;
const left = Number.parseFloat(floatingButton.style.left || "0");
const top = Number.parseFloat(floatingButton.style.top || "0");
applyFloatingPosition(floatingButton, left, top);
});
floatingButton.dataset.cpDragBound = "1";
}
function syncHistoryButtons() {
const backwards = byUiId("cheat-history-backwards");
const forwards = byUiId("cheat-history-forwards");
const gameBack = byUiId("history-backward") || document.getElementById("history-backward");
const gameForward = byUiId("history-forward") || document.getElementById("history-forward");
if (!backwards || !forwards || !gameBack || !gameForward) return;
backwards.disabled = gameBack.disabled;
forwards.disabled = gameForward.disabled;
}
function Enable_cheat_history() {
var button_back = byUiId("cheat-history-backwards");
var button_forward = byUiId("cheat-history-forwards");
var button_set = byUiId("Enable_cheat_history") || document.getElementById("Enable_cheat_history");
if (!button_back || !button_forward || !button_set) return;
if (button_back.hidden == true) {
button_back.hidden = false;
button_forward.hidden = false;
button_set.innerHTML = "Disable";
syncHistoryButtons();
} else {
button_back.hidden = true;
button_forward.hidden = true;
button_set.innerHTML = "Enable";
}
}
function Enable_sidebar_button() {
var button = byUiId("cheat-sidebar");
var sidebar_button = document.getElementById("Enable_sidebar_button");
if (!button || !sidebar_button) return;
if (button.hidden == true) {
button.hidden = false;
sidebar_button.innerHTML = "Disable";
} else {
button.hidden = true;
sidebar_button.innerHTML = "Enable";
}
}
function simple_cheat_button() {
const cheatButton = byUiId("cheat-open");
const simpleCheatButton = document.getElementById("simple_cheat_button");
if (!cheatButton || !simpleCheatButton) return;
const isDisabled = simpleCheatButton.innerHTML === "Disable";
simpleCheatButton.innerHTML = isDisabled ? "Enable" : "Disable";
cheatButton.innerHTML = isDisabled ? "Cheat" : "\u2699";
cheatButton.style.fontSize = isDisabled ? "" : "89%";
}
// src/ui/theme/base.css
var base_default = "#cheat{font-family:var(--cp-font-ui,Arial,sans-serif);color:var(--cp-text-primary,#fff);}#effect-layer{z-index:999;background-color:red;opacity:0;position:fixed;top:0;left:0;width:100%;height:100%;}.hidden{display:none;}@media (prefers-reduced-motion:reduce){.fade{transition:none;}}.fade:not(.show){opacity:0;}.collapse:not(.show){display:none;}.collapsing{height:0;overflow:hidden;transition:height 0.35s ease;}@media (prefers-reduced-motion:reduce){.collapsing{transition:none;}}.collapsing.collapse-horizontal{width:0;height:auto;transition:width 0.35s ease;}@media (prefers-reduced-motion:reduce){.collapsing.collapse-horizontal{transition:none;}}.gold{color:var(--cp-color-gold,#f0d46d);}.linkBlue{color:var(--cp-color-link,#66a7ff);}@keyframes shake{0%{transform:translate(0px,0px);}25%{transform:translate(2px,-2px);}50%{transform:translate(-2px,2px);}75%{transform:translate(2px,-2px);}100%{transform:translate(0px,0px);}}.shake{animation:shake 0.3s linear infinite;}";
// src/ui/theme/floating.css
var floating_default = "#floating-button{position:fixed;top:2%;right:20px;z-index:899;display:flex;flex-direction:row;gap:5px;transition:top 0.5s ease-in-out;}#floating-button button{min-height:34px;padding:0 12px;border-radius:8px;border:1px solid rgba(255,255,255,0.35);background:linear-gradient(180deg,#575757 0%,#3f3f3f 100%);color:#f2f2f2;font-weight:600;}#floating-button button:hover{background:linear-gradient(180deg,#646464 0%,#474747 100%);}#floating-button #cheat-open{cursor:grab;touch-action:none;padding:0 16px;border-color:rgba(240,212,109,0.55);box-shadow:0 0 0 1px rgba(240,212,109,0.18);}#floating-button.cp-dragging,#floating-button.cp-dragging #cheat-open{cursor:grabbing;user-select:none;}#floating-button.cp-dragging,#floating-button.cp-custom-position{transition:none;}#floating-button.moved{top:90%;}";
// src/ui/theme/modal.css
var modal_default = ".modal{display:none;position:fixed;z-index:900;left:0;top:0;width:100%;height:100%;overflow:auto;background-color:var(--cp-color-overlay,rgba(0,0,0,0.5));}.modal-content{background-color:var(--cp-bg-modal,#222);margin:10px auto;border:1px solid var(--cp-border-modal,#888);border-radius:10px;width:min(960px,94vw);overflow:hidden;box-shadow:0 18px 44px rgba(0,0,0,0.45);}.modal-content-padding{box-sizing:border-box;padding:5px 0 9px;display:flex;flex-wrap:wrap;align-items:center;column-gap:10px;row-gap:8px;scroll-margin-top:58px;}.cp-layout-heading{padding-top:14px;padding-bottom:7px;font-weight:600;}.cp-layout-help{padding-bottom:10px;}.cp-layout-spacer{min-height:10px;padding:0;}.cp-layout-footer{margin-top:14px;padding-top:12px;border-top:1px solid rgba(255,255,255,0.12);}.cp-section-shell{display:contents;}.cp-shell-help{color:#9cbcff;font-size:0.9em;}.cp-cheat-descriptor{display:grid;grid-template-columns:minmax(150px,max-content) minmax(0,1fr);align-items:start;column-gap:12px;min-width:0;}.cp-cheat-label{min-height:32px;display:inline-flex;align-items:center;font-weight:400;gap:7px;}.cp-cheat-controls{min-width:0;display:flex;flex-wrap:wrap;align-items:center;column-gap:10px;row-gap:8px;}.cp-cheat-control-unit{min-width:0;max-width:100%;display:inline-flex;align-items:center;gap:10px;break-inside:avoid;}.cp-cheat-status{grid-column:1 / -1;margin-left:162px;color:#f2c879;line-height:1.35;}.cp-cheat-unavailable{border-left:3px solid #b47a36;padding-left:9px;}.cp-control-notice{flex-basis:100%;color:var(--cp-text-muted,#c8c3bc);line-height:1.3;}.cp-control-notice[data-notice-kind='warning']{color:#f2c879;}.cp-confirmation-control{padding:2px 7px;border:1px solid rgba(240,212,109,0.35);border-radius:6px;}.cp-status-control{flex:0 0 auto;}.cp-cheat-control-unit[hidden]{display:none;}.cp-status-chip{display:inline-flex;align-items:center;min-height:24px;box-sizing:border-box;padding:2px 9px;border:1px solid rgba(102,167,255,0.45);border-radius:999px;background:rgba(102,167,255,0.12);color:#c9dcff;line-height:1.2;white-space:nowrap;}.cp-cheat-control-unit>.modal-content-width,.cp-cheat-control-unit>select{max-width:min(100%,320px);}.modal-content-width{box-sizing:border-box;min-height:32px;padding:0 10px;border-radius:6px;border:1px solid var(--cp-border-button,#8a8a8a);background:#151515;color:var(--cp-text-primary,#fff);}.cp-cheat-control:focus-visible{outline:2px solid var(--cp-color-link,#66a7ff);outline-offset:2px;}.cp-cheat-control:disabled{cursor:not-allowed;opacity:0.55;}.cp-cheat-range{accent-color:var(--cp-color-gold,#f0d46d);}.cp-search-row{position:sticky;top:0;z-index:2;background:var(--cp-bg-modal,#222);padding-top:4px;display:flex;align-items:center;gap:8px;}.cp-search-input{width:min(460px,96%);box-sizing:border-box;min-height:32px;padding:0 10px;border-radius:6px;border:1px solid var(--cp-border-button,#8a8a8a);background:#151515;color:var(--cp-text-primary,#fff);}.cp-search-input::placeholder{color:#9f9f9f;}.modal-button{background:var(--cp-bg-button,#4b4b4b);color:var(--cp-text-primary,#fff);border:1px solid var(--cp-border-button,#8a8a8a);border-radius:var(--cp-radius-button,2px);min-height:32px;padding:0 10px;line-height:1;display:inline-flex;align-items:center;justify-content:center;white-space:nowrap;cursor:pointer;}.modal-content select{min-height:32px;padding:0 28px 0 10px;border-radius:6px;border:1px solid var(--cp-border-button,#8a8a8a);background:#151515;color:var(--cp-text-primary,#fff);}.modal-button:hover{background:var(--cp-bg-button-hover,#5a5a5a);}.modal-button.cp-toggle-active{background:var(--cp-color-gold,#f0d46d);color:#1a1a1a;border-color:var(--cp-color-gold,#f0d46d);}.modal-button.cp-toggle-active:hover{background:#d4b84a;border-color:#d4b84a;}.modal-button[hidden],.modal-toggle[hidden],.modal-link[hidden],.modal-toggle[hidden] *{display:none !important;}.modal-toggle{display:inline-flex;align-items:center;gap:6px;cursor:pointer;user-select:none;border:1px solid transparent;border-radius:999px;padding:2px 8px;transition:border-color 0.2s ease,background-color 0.2s ease;}.modal-toggle input[type='checkbox']{width:14px;height:14px;margin:0;cursor:pointer;}.modal-toggle .toggle-label{color:var(--cp-text-muted,#c8c3bc);}.modal-toggle input[type='checkbox']:checked + .toggle-label{color:var(--cp-color-gold,#f0d46d);font-weight:700;}.modal-toggle.cp-toggle-active{border-color:rgba(240,212,109,0.65);background:rgba(240,212,109,0.12);}.modal-toggle[aria-disabled='true']{cursor:not-allowed;opacity:0.7;}.modal-toggle:has(input[hidden]){display:none !important;}.cp-bound-value{margin-left:8px;color:var(--cp-text-muted,#c8c3bc);font-size:11px;opacity:0.9;}.modal-link{color:var(--cp-color-link,#66a7ff);text-decoration:underline;}.modal-content-color{color:var(--cp-text-muted,#c8c3bc);}.modal-content-right{margin-right:10px;}.tooltip-small{position:relative;display:inline-block;cursor:help;}.tooltip-small span{visibility:hidden;width:300px;max-width:min(70vw,300px);background:var(--cp-bg-tooltip,#111);color:var(--cp-text-tooltip,#f2f2f2);border:1px solid var(--cp-border-tooltip,#444);border-radius:var(--cp-radius-tooltip,4px);padding:6px 8px;position:absolute;z-index:1000;left:0;top:1.4em;white-space:normal;}.tooltip-small:hover span,.tooltip-small:focus span,.tooltip-small:focus-within span{visibility:visible;}.tooltip-small[hidden]{display:none;}.close{cursor:pointer;}.navbar .close{flex:0 0 52px;width:52px;min-width:52px;border-right:0;padding:8px 0;font-size:24px;font-weight:700;line-height:1;color:#ffe5e5;background:linear-gradient(180deg,#6b2d2d 0%,#542222 100%);transition:background-color 0.2s ease,color 0.2s ease;}.navbar .close:hover,.navbar .close:focus{color:#ffffff;background:linear-gradient(180deg,#7d3636 0%,#632c2c 100%);}#modal-content-container{display:flex;flex-direction:column;}.modal-row{display:flex;justify-content:space-between;align-items:center;margin-bottom:10px;}.modal-label{flex:1;}.modal-inputs{flex:2;}#modal-content-container{height:72vh;max-height:72vh;overflow-y:auto;overscroll-behavior:contain;scroll-padding:58px 0 64px;}.navbar{display:flex;justify-content:space-between;align-items:center;background-color:var(--cp-bg-navbar,#333);color:var(--cp-text-primary,#fff);}.nav-link{width:100%;cursor:pointer;text-align:center;position:relative;border-right:1px solid rgba(255,255,255,0.3);padding:10px;}.nav-link.active{text-decoration:underline;}.cheat-content{box-sizing:border-box;width:100%;padding:1rem 1rem 3rem !important;display:none;}.cheat-content.active{display:block;}.content{display:none;padding:10px;}.content.active{display:block;}.cp-section-broken{border:1px solid #9f2d2d;background:rgba(159,45,45,0.12);}.cp-section-broken-banner{background:#9f2d2d;color:#fff;padding:6px 8px;margin-bottom:8px;font-size:12px;}";
// src/ui/theme/responsive.css
var responsive_default = "@media (max-width:768px){.modal-content{width:96vw;margin:8px auto;}#modal-content-container{height:72vh;max-height:72vh;overflow-y:auto;}.cp-search-row{flex-wrap:wrap;}.cp-search-input{width:100%;}.cp-cheat-descriptor{grid-template-columns:minmax(0,1fr);row-gap:5px;padding-top:9px;padding-bottom:12px;}.cp-cheat-label{min-height:auto;}.cp-cheat-status{margin-left:0;}.cp-cheat-controls{width:100%;}.cp-cheat-control-unit{max-width:100%;}.cp-cheat-control-unit>.modal-content-width,.cp-cheat-control-unit>select{min-width:0;max-width:min(100%,280px);}.toast-container,#toastContainer,#cp-fallback-toast-container{left:50%;right:auto;transform:translateX(-50%);width:min(92vw,420px);}}@media (max-width:480px){.cheat-content{padding:0.75rem 0.75rem 3.5rem !important;}.cp-cheat-controls{column-gap:8px;}}";
// src/ui/theme/toast.css
var toast_default = ".toast-container,#toastContainer,#cp-fallback-toast-container{position:fixed;top:max(12px,env(safe-area-inset-top));right:max(12px,env(safe-area-inset-right));z-index:999;display:flex;flex-direction:column;gap:8px;pointer-events:none;width:min(90vw,380px);}.toast{background-color:var(--cp-bg-toast,#333);color:var(--cp-text-toast,#fff);padding:10px 14px;border-radius:var(--cp-radius-toast,5px);border:1px solid rgba(255,255,255,0.15);opacity:1;transform:translateY(0);transition:opacity 0.2s ease,transform 0.2s ease;box-shadow:0 10px 28px rgba(0,0,0,0.35);backdrop-filter:blur(2px);}.toast-title{font-weight:700;font-size:12px;margin-bottom:2px;}.toast-body{font-size:13px;line-height:1.35;}.toast--success{border-color:#3a9d5d;background-color:#193524;}.toast--warning{border-color:#be8e2d;background-color:#3e2f12;}.toast--error{border-color:#b24646;background-color:#441d1d;}.toast--info{border-color:#4d84d3;background-color:#1a2b44;}.toast-enter{opacity:0;transform:translateY(-10px);}.toast-show{opacity:1;transform:translateY(0);}.toast-leave{opacity:0;transform:translateY(-10px);}";
// src/ui/theme/tokens.css
var tokens_default = ":host{--cp-color-gold:#f0d46d;--cp-color-link:#66a7ff;--cp-color-danger:#e05a5a;--cp-color-overlay:rgba(0,0,0,0.5);--cp-bg-modal:#222;--cp-bg-navbar:#333;--cp-bg-button:#4b4b4b;--cp-bg-button-hover:#5a5a5a;--cp-bg-tooltip:#111;--cp-bg-toast:#333;--cp-text-primary:#fff;--cp-text-muted:#c8c3bc;--cp-text-tooltip:#f2f2f2;--cp-text-toast:#fff;--cp-border-modal:#888;--cp-border-button:#8a8a8a;--cp-border-tooltip:#444;--cp-spacing-xs:2px;--cp-spacing-sm:5px;--cp-spacing-md:10px;--cp-spacing-lg:20px;--cp-spacing-content:1rem;--cp-radius-button:2px;--cp-radius-tooltip:4px;--cp-radius-toast:5px;--cp-font-ui:system-ui,-apple-system,sans-serif;--cp-font-size-base:13px;--cp-transition-fade:opacity 0.3s ease-in-out;--cp-transition-collapse:height 0.35s ease;--cp-transition-float:top 0.5s ease-in-out;}";
// src/ui/index.js
registerSheet(tokens_default, { target: "shadow" });
registerSheet(base_default, { target: "shadow" });
registerSheet(floating_default, { target: "shadow" });
registerSheet(toast_default, { target: "shadow" });
registerSheet(modal_default, { target: "shadow" });
registerSheet(responsive_default, { target: "shadow" });
function bindOnce(element, flag, eventName, handler) {
if (!element || element[flag]) return;
element.addEventListener(eventName, handler);
element[flag] = true;
}
function shouldCloseModalFromTarget(target) {
if (!target?.id) return false;
if (target.id !== "modal") return false;
const modal2 = byUiId("modal");
if (!modal2) return true;
const content = modal2.querySelector(".modal-content");
return !(content && content.contains(target));
}
function mountInterface() {
if (!document.body) {
requestAnimationFrame(mountInterface);
return;
}
const root = ensureShadowRoot();
if (!root) {
logger_default("ui", "mountInterface: ensureShadowRoot returned null");
return;
}
if (byUiId("cheat")) return;
const styleApplied = safeCall("CSS injection failed:", () => {
applyToShadow(root);
return true;
});
if (!styleApplied) {
}
root.appendChild(renderTemplate(layoutTemplate));
refreshUiRefs();
initFloatingButtonDrag();
logger_default("ui", "mountInterface: mounted template", {
data: { modalContainer: !!byUiId("modal-content-container") }
});
safeCall("failed to bind fallback open handler", () => {
const btn = byUiId("cheat-open");
bindOnce(btn, "__cheatPlusBound", "click", () => {
safeCall("openModal failed:", () => openModal());
});
const btnSidebar = byUiId("cheat-sidebar");
bindOnce(btnSidebar, "__cheatPlusBoundSidebar", "click", () => {
safeCall("cheat-sidebar failed:", () => dispatch("cheat-sidebar"));
});
const histBack = byUiId("cheat-history-backwards");
bindOnce(histBack, "__cheatPlusBoundHistBack", "click", () => {
safeCall("history-back failed:", () => dispatch("cheat-history-backwards"));
});
const histFor = byUiId("cheat-history-forwards");
bindOnce(histFor, "__cheatPlusBoundHistFor", "click", () => {
safeCall("history-for failed:", () => dispatch("cheat-history-forwards"));
});
const rootEl = byUiId("cheat");
bindOnce(rootEl, "__cheatPlusCloseBound", "click", (event) => {
const target = event.target;
if (!shouldCloseModalFromTarget(target)) return;
safeCall("closeModal fallback failed:", () => closeModal());
});
});
}
// src/platform/sugarcube/state.js
function getSugarCube() {
const rw2 = getRuntimeWindow();
return rw2?.SugarCube ?? null;
}
function getVars() {
return getSugarCube()?.State?.variables ?? null;
}
function getSetup() {
return getSugarCube()?.setup ?? null;
}
function getPassage() {
return getVars()?.passage ?? null;
}
function isReady() {
return Boolean(getSugarCube()?.State?.variables);
}
// src/platform/sugarcube/selectors.js
function getVariable(key) {
return getVars()?.[key];
}
function setVariable(key, value) {
const vars = getVars();
if (vars) vars[key] = value;
}
function getSetupKey(key) {
return getSetup()?.[key];
}
// src/platform/sugarcube/quirks.js
function isAtPassage(name) {
return getPassage() === name;
}
function isAtSettings() {
return isAtPassage("Settings");
}
// src/platform/sugarcube/adapter.js
var scAdapter = {
// --- State access ---
getVariables: getVars,
getVariable,
setVariable,
// --- Setup ---
getSetup,
getSetupKey,
// --- Passage / navigation ---
getCurrentPassage: getPassage,
isAtPassage,
// --- Lifecycle ---
isReady
};
// src/platform/sugarcube/constants.js
var GAME_VERSION_ELEMENT_ID = "gameVersionDisplay2";
// src/platform/sugarcube/runtime-engine.js
function hasSugarCubeCorePrerequisites() {
const runtimeWindow2 = getRuntimeWindow();
return Boolean(runtimeWindow2?.SugarCube && scAdapter.isReady());
}
function hasSugarCubeRuntimePrerequisites() {
const setup = scAdapter.getSetup();
return Boolean(
hasSugarCubeCorePrerequisites() && Array.isArray(setup?.NPCNameList) && document.getElementById(GAME_VERSION_ELEMENT_ID)
);
}
function describeSugarCubePrerequisiteState() {
const runtimeWindow2 = getRuntimeWindow();
const sugarCube = runtimeWindow2?.SugarCube;
return {
sugarCubeDefined: Boolean(sugarCube),
sugarCubeState: Boolean(sugarCube?.State),
sugarCubeVariables: Boolean(sugarCube?.State?.variables),
sugarCubeSetup: Boolean(sugarCube?.setup),
npcList: Array.isArray(sugarCube?.setup?.NPCNameList),
versionElement: Boolean(document.getElementById(GAME_VERSION_ELEMENT_ID))
};
}
var sugarcubeRuntimeEngine = Object.freeze({
id: "sugarcube",
label: "SugarCube",
detect() {
return Boolean(getRuntimeWindow()?.SugarCube);
},
adapter: scAdapter,
hasCorePrerequisites: hasSugarCubeCorePrerequisites,
hasRuntimePrerequisites: hasSugarCubeRuntimePrerequisites,
describePrerequisiteState: describeSugarCubePrerequisiteState
});
// src/platform/renpy-web/adapter.js
function getRenPyRoot() {
const runtimeWindow2 = getRuntimeWindow();
return runtimeWindow2?.RenPyWeb ?? null;
}
function getStore3() {
const root = getRenPyRoot();
return root?.store ?? null;
}
var renpyWebAdapter = {
getVariables: getStore3,
getVariable(key) {
const store2 = getStore3();
return store2 ? store2[key] : void 0;
},
setVariable(key, value) {
const store2 = getStore3();
if (store2) store2[key] = value;
},
getSetup() {
return getRenPyRoot()?.setup ?? null;
},
getSetupKey(key) {
const setup = getRenPyRoot()?.setup;
return setup ? setup[key] : void 0;
},
getCurrentPassage() {
return getRenPyRoot()?.passage ?? null;
},
isAtPassage(name) {
return this.getCurrentPassage() === name;
},
isReady() {
return Boolean(getStore3());
}
};
// src/platform/renpy-web/runtime-engine.js
function hasRenPyWebCorePrerequisites() {
return renpyWebAdapter.isReady();
}
function hasRenPyWebRuntimePrerequisites() {
return hasRenPyWebCorePrerequisites();
}
function describeRenPyWebPrerequisiteState() {
const runtimeWindow2 = getRuntimeWindow();
const renpyWeb = runtimeWindow2?.RenPyWeb;
return {
renpyWebDefined: Boolean(renpyWeb),
storeDefined: Boolean(renpyWeb?.store),
setupDefined: Boolean(renpyWeb?.setup),
passageDefined: Boolean(renpyWeb?.passage)
};
}
var renpyWebRuntimeEngine = Object.freeze({
id: "renpy-web",
label: "RenPy-web",
detect() {
return Boolean(getRuntimeWindow()?.RenPyWeb);
},
adapter: renpyWebAdapter,
hasCorePrerequisites: hasRenPyWebCorePrerequisites,
hasRuntimePrerequisites: hasRenPyWebRuntimePrerequisites,
describePrerequisiteState: describeRenPyWebPrerequisiteState
});
// src/platform/runtime-engine-registry.js
var runtimeEngines = [sugarcubeRuntimeEngine, renpyWebRuntimeEngine];
var activeRuntimeEngine = null;
function resolveRuntimeEngine() {
return runtimeEngines.find((engine) => {
try {
return engine.detect();
} catch (_) {
return false;
}
}) ?? null;
}
function ensureActiveRuntimeEngine() {
if (activeRuntimeEngine) return activeRuntimeEngine;
const resolved = resolveRuntimeEngine();
if (resolved) activeRuntimeEngine = resolved;
return activeRuntimeEngine;
}
// src/cheat/contract/config-schema.js
var entry = (path7, type, defaultValue, description, migrationAliases = []) => Object.freeze({ path: path7, type, scope: "save", defaultValue, description, migrationAliases });
var CHEAT_CONFIG_SCHEMA = Object.freeze([
entry("angel", "number", 0, "Saved angel-stat baseline."),
entry("angelMode", "boolean", true, "Whether angel baseline restoration is active."),
entry("toggles", "object", {}, "Active stable toggle IDs."),
entry("storedNPCs", "object", {}, "CheatPlus-managed overflow NPC pregnancy data."),
entry("storedNPCsDate", "number", 0, "Last game day overflow NPC data was processed."),
entry("storedNPCsPriority", "number", 0, "Overflow NPC processing priority."),
entry("trueDivine", "string", "", "Remembered demon/angel transformation branch."),
entry("orgasmCount", "number", 0, "Intense-cum toggle counter."),
entry("baseNpcPregnancyChance", "number-or-null", null, "Baseline restored by NPC toggle."),
entry("unlicumMode", "boolean", false, "Intense-cum toggle phase.")
]);
var CHEAT_CONFIG_DEFAULTS = Object.freeze(
Object.fromEntries(CHEAT_CONFIG_SCHEMA.map(({ path: path7, defaultValue }) => [path7, defaultValue]))
);
var CHEAT_CONFIG_CLASSIFICATION = Object.freeze({
saveBackedConfig: Object.freeze(CHEAT_CONFIG_SCHEMA.map(({ path: path7 }) => path7)),
transientRuntimeState: Object.freeze([
"scheduler callbacks",
"failure counters",
"cooldown timestamps",
"mounted controls",
"AbortController instances"
]),
gameState: Object.freeze([
"money",
"arousal",
"date",
"player",
"NPCName",
"storedNPCs (base-game path)",
"pregnancy",
"setup"
])
});
function isPlainObject(value) {
return Boolean(value) && typeof value === "object" && !Array.isArray(value);
}
function isCheatConfigValueValid(definition, value) {
if (definition.type === "number") return Number.isFinite(value);
if (definition.type === "number-or-null") return value === null || Number.isFinite(value);
if (definition.type === "boolean") return typeof value === "boolean";
if (definition.type === "string") return typeof value === "string";
if (definition.type === "object") return isPlainObject(value);
return false;
}
function cloneDefault(value) {
return isPlainObject(value) ? { ...value } : value;
}
function normalizeCheatConfig(input, { baseNpcPregnancyChance = null } = {}) {
const source = isPlainObject(input) ? input : {};
const normalized = {};
for (const definition of CHEAT_CONFIG_SCHEMA) {
let value = source[definition.path];
if (value === void 0) {
for (const alias of definition.migrationAliases) {
if (source[alias] !== void 0) {
value = source[alias];
break;
}
}
}
if (!isCheatConfigValueValid(definition, value)) value = cloneDefault(definition.defaultValue);
normalized[definition.path] = value;
}
if (normalized.baseNpcPregnancyChance === null && Number.isFinite(baseNpcPregnancyChance)) {
normalized.baseNpcPregnancyChance = baseNpcPregnancyChance;
}
return normalized;
}
// src/platform/sugarcube/cheat-config.js
function cfg() {
return getVars()?.cheatPlus ?? null;
}
function initCheatConfig() {
const vars = getVars();
if (!vars) return;
vars.cheatPlus = normalizeCheatConfig(vars.cheatPlus, {
baseNpcPregnancyChance: vars.baseNpcPregnancyChance
});
const c = vars.cheatPlus;
if (!c.trueDivine && vars.penisstate === 0 && vars.vaginastate === 0) {
c.trueDivine = vars.demon > 0 ? "demon" : vars.angel > 0 ? "angel" : "";
}
}
function getToggles() {
return cfg()?.toggles ?? {};
}
function activateToggle(id) {
const c = cfg();
if (c) c.toggles[id] = id;
}
function deactivateToggle(id) {
const c = cfg();
if (c) delete c.toggles[id];
}
function getBaseNpcPregnancyChance() {
return cfg()?.baseNpcPregnancyChance;
}
// src/platform/sugarcube/config-storage.js
function initStorage() {
initCheatConfig();
}
// src/ui/shell/toast.js
var FALLBACK_CONTAINER_ID = "cp-fallback-toast-container";
var MAX_TOASTS = 4;
var DEFAULT_DURATION = 3e3;
var toastSequence = 0;
function ensureFallbackContainer() {
let container = document.getElementById(FALLBACK_CONTAINER_ID);
if (container) return container;
container = document.createElement("div");
container.id = FALLBACK_CONTAINER_ID;
container.className = "toast-container";
document.body.appendChild(container);
return container;
}
function getToastContainer() {
const shadowContainer = byUiId("toastContainer");
if (shadowContainer) return shadowContainer;
return ensureFallbackContainer();
}
function normalizeToastArgs(message, optionsOrDuration) {
if (typeof optionsOrDuration === "number") {
return {
message,
duration: optionsOrDuration,
variant: "info"
};
}
return {
message,
duration: optionsOrDuration?.duration ?? DEFAULT_DURATION,
variant: optionsOrDuration?.variant ?? "info",
title: optionsOrDuration?.title
};
}
function showToast(message, optionsOrDuration) {
const { duration, variant, title } = normalizeToastArgs(message, optionsOrDuration);
const toastContainer2 = getToastContainer();
if (!toastContainer2) return;
const toast = document.createElement("div");
toast.classList.add("toast", "toast-enter", `toast--${variant}`);
if (title) {
const titleEl = document.createElement("div");
titleEl.className = "toast-title";
titleEl.textContent = title;
toast.appendChild(titleEl);
}
const bodyEl = document.createElement("div");
bodyEl.className = "toast-body";
bodyEl.textContent = message;
toast.appendChild(bodyEl);
toast.dataset.cpToastSequence = String(++toastSequence);
toastContainer2.appendChild(toast);
while (toastContainer2.children.length > MAX_TOASTS) {
toastContainer2.firstElementChild?.remove();
}
requestAnimationFrame(() => {
toast.classList.remove("toast-enter");
toast.classList.add("toast-show");
});
setTimeout(() => {
toast.classList.remove("toast-show");
toast.classList.add("toast-leave");
setTimeout(() => {
toast.remove();
}, 200);
}, duration);
}
// src/ui/shell/ui-display.js
function hideAllContent() {
const { quicklink: quicklink2, statlink: statlink2, misclink: misclink2, quickcontent: quickcontent2, statscontent: statscontent2, misccontent: misccontent2 } = getUiRefs();
if (!quicklink2 || !statlink2 || !misclink2 || !quickcontent2 || !statscontent2 || !misccontent2) {
return;
}
[quicklink2, statlink2, misclink2].forEach((link) => link.classList.remove("gold"));
[quickcontent2, statscontent2, misccontent2].forEach(
(content) => content.classList.remove("active")
);
}
function showContent(nav, contentElement) {
if (!nav || !contentElement) return;
hideAllContent();
nav.classList.add("gold");
contentElement.classList.add("active");
}
// src/app/active-cheat-runtime.js
var activeBuilder = null;
function setActiveCheatBuilder(builder) {
activeBuilder = builder ?? null;
return activeBuilder;
}
function getActiveCheatBuilder() {
return activeBuilder;
}
// src/app/commands/shell-commands.js
var SECTIONS = Object.freeze([
{ action: "quick-link", section: "quick", nav: "quicklink", content: "quickcontent" },
{ action: "stats-link", section: "stats", nav: "statlink", content: "statscontent" },
{ action: "misc-link", section: "misc", nav: "misclink", content: "misccontent" }
]);
var APPLICATION_SHELL_ACTION_IDS = Object.freeze([
...SECTIONS.map(({ action }) => action),
"cheat-open",
"cheat-history-backwards",
"cheat-history-forwards",
"cheat-sidebar",
"init_interface",
"Enable_cheat_history",
"Enable_sidebar_button",
"simple_cheat_button",
"save_data",
"load_data"
]);
function openSidebar() {
byUiId("ui-bar-toggle")?.click();
}
function navigateHistory(id, unavailable) {
const button = byUiId(id);
if (!button) {
unavailable?.("Failed, history probably disabled.");
return false;
}
button.click();
syncHistoryButtons();
return true;
}
function navigateHistoryBackward(unavailable) {
return navigateHistory("history-backward", unavailable);
}
function navigateHistoryForward(unavailable) {
return navigateHistory("history-forward", unavailable);
}
function registerApplicationShellCommands({
openModal: openModal2,
showContent: showContent2,
showToast: showToast2,
initInterface,
enableCheatHistory,
enableSidebarButton,
toggleSimpleCheatButton
}) {
const handlers = /* @__PURE__ */ new Map();
const add = (id, handler) => {
handlers.set(id, handler);
register(id, handler);
};
for (const entry2 of SECTIONS) {
add(entry2.action, () => {
const refs = getUiRefs();
showContent2(refs?.[entry2.nav], refs?.[entry2.content]);
return getActiveCheatBuilder()?.sectionOpened(entry2.section);
});
}
add("cheat-open", openModal2);
add("cheat-history-backwards", () => navigateHistoryBackward(showToast2));
add("cheat-history-forwards", () => navigateHistoryForward(showToast2));
add("cheat-sidebar", openSidebar);
add("init_interface", initInterface);
add("Enable_cheat_history", enableCheatHistory);
add("Enable_sidebar_button", enableSidebarButton);
add("simple_cheat_button", toggleSimpleCheatButton);
const unavailableServerCommand = (operation) => () => {
showToast2(`Server save ${operation} is not available in this build.`, { variant: "warning" });
return false;
};
add("save_data", unavailableServerCommand("export"));
add("load_data", unavailableServerCommand("import"));
return Object.freeze({ ids: Object.freeze([...handlers.keys()]) });
}
// src/cheat/create-cheat.js
var FIELDS = /* @__PURE__ */ new Set([
"id",
"location",
"meta",
"actions",
"sync",
"refresh",
"toggle",
"effect",
"isApplicable",
"requiredPaths",
"onEnable",
"onDisable",
"dispose",
"config",
"diagnostics"
]);
var SECTIONS2 = /* @__PURE__ */ new Set(["quick", "stats", "misc"]);
var CONTROLS = /* @__PURE__ */ new Set(["button", "input", "range", "select", "text", "toggle"]);
var REFRESH = /* @__PURE__ */ new Set(["mount", "section-open", "after-action", "runtime-tick", "manual"]);
var CADENCES = /* @__PURE__ */ new Set(["frame", "daily"]);
var CONTROL_INTENTS = /* @__PURE__ */ new Set(["confirmation", "status"]);
var CONFIG_PATHS = new Set(CHEAT_CONFIG_SCHEMA.map(({ path: path7 }) => path7));
var CHEAT_CONTRACT_CONSTANTS = Object.freeze({
sections: Object.freeze([...SECTIONS2]),
controlTypes: Object.freeze([...CONTROLS]),
refreshReasons: Object.freeze([...REFRESH]),
toggleCadences: Object.freeze([...CADENCES])
});
var plain = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value) && [Object.prototype, null].includes(Object.getPrototypeOf(value));
var text = (value) => typeof value === "string" && value.trim() !== "";
function stringArray(value, label) {
if (!Array.isArray(value) || value.some((item) => !text(item))) {
throw new TypeError(`${label} must be an array of non-empty strings.`);
}
const seen = /* @__PURE__ */ new Set();
for (const item of value) {
if (seen.has(item)) throw new Error(`${label} contains duplicate "${item}".`);
seen.add(item);
}
}
function validateCheatDefinition(definition) {
if (!plain(definition)) throw new TypeError("Cheat definition must be a plain object.");
for (const key of Object.keys(definition)) {
if (!FIELDS.has(key)) throw new Error(`Unknown cheat descriptor field "${key}".`);
}
if (!text(definition.id)) throw new TypeError("Cheat id must be a non-empty string.");
if (!/^[a-z0-9]+(?:[.-][a-z0-9]+)+$/.test(definition.id)) {
throw new Error(`Cheat id "${definition.id}" must be a lowercase namespaced id.`);
}
if (!plain(definition.location))
throw new TypeError(`Cheat "${definition.id}" location must be a plain object.`);
if (!SECTIONS2.has(definition.location.section))
throw new Error(`Cheat "${definition.id}" has unsupported section.`);
if (!Number.isFinite(definition.location.order))
throw new TypeError(`Cheat "${definition.id}" location.order must be finite.`);
if (definition.location.group != null && !text(definition.location.group))
throw new TypeError(`Cheat "${definition.id}" location.group must be a non-empty string.`);
if (!plain(definition.meta) || !text(definition.meta.label))
throw new TypeError(`Cheat "${definition.id}" meta.label must be a non-empty string.`);
if (definition.meta.confirmation != null && !text(definition.meta.confirmation))
throw new TypeError(`Cheat "${definition.id}" meta.confirmation must be a non-empty string.`);
if (!Array.isArray(definition.meta.controls) || definition.meta.controls.length === 0)
throw new TypeError(`Cheat "${definition.id}" meta.controls must be a non-empty array.`);
if (definition.actions != null && !plain(definition.actions))
throw new TypeError(`Cheat "${definition.id}" actions must be a plain object.`);
for (const [name, action] of Object.entries(definition.actions ?? {})) {
if (!text(name) || typeof action !== "function")
throw new TypeError(`Cheat "${definition.id}" action "${name}" must be a function.`);
}
const keys = /* @__PURE__ */ new Set();
for (const control of definition.meta.controls) {
if (!plain(control) || !text(control.key))
throw new TypeError(`Cheat "${definition.id}" control key must be a non-empty string.`);
if (keys.has(control.key))
throw new Error(`Cheat "${definition.id}" has duplicate control key "${control.key}".`);
keys.add(control.key);
if (!CONTROLS.has(control.type))
throw new Error(`Cheat "${definition.id}" control "${control.key}" has invalid type.`);
if (control.intent != null && !CONTROL_INTENTS.has(control.intent))
throw new Error(`Cheat "${definition.id}" control "${control.key}" has invalid intent.`);
if (control.intent === "confirmation" && control.type !== "toggle")
throw new Error(`Cheat "${definition.id}" confirmation control must be a toggle.`);
if (control.intent === "status" && control.type !== "text")
throw new Error(`Cheat "${definition.id}" status control must be text.`);
if (control.action && !(control.action === "toggle" && definition.toggle) && typeof definition.actions?.[control.action] !== "function")
throw new Error(
`Cheat "${definition.id}" control "${control.key}" references missing local action "${control.action}".`
);
if (control.binding != null && (!plain(control.binding) || !text(control.binding.path)))
throw new TypeError(
`Cheat "${definition.id}" control binding path must be a non-empty string.`
);
if (control.binding?.writeOn != null && !["input", "change"].includes(control.binding.writeOn))
throw new Error(
`Cheat "${definition.id}" control "${control.key}" has invalid binding writeOn event.`
);
if (control.options != null && !Array.isArray(control.options) && typeof control.options !== "function")
throw new TypeError(
`Cheat "${definition.id}" control "${control.key}" options must be an array or function.`
);
if (control.fallbackOptions != null && !Array.isArray(control.fallbackOptions))
throw new TypeError(
`Cheat "${definition.id}" control "${control.key}" fallbackOptions must be an array.`
);
}
if (definition.refresh != null) {
stringArray(definition.refresh, `Cheat "${definition.id}" refresh`);
for (const reason of definition.refresh)
if (!REFRESH.has(reason))
throw new Error(`Cheat "${definition.id}" has invalid refresh reason "${reason}".`);
}
if (definition.toggle != null) {
if (!plain(definition.toggle) || !CADENCES.has(definition.toggle.cadence))
throw new Error(`Cheat "${definition.id}" has invalid toggle cadence.`);
if (typeof definition.effect !== "function")
throw new TypeError(`Cheat "${definition.id}" toggle requires effect().`);
if (!definition.meta.controls.some(({ type }) => type === "toggle"))
throw new Error(`Cheat "${definition.id}" toggle requires a toggle control.`);
if (definition.toggle.cooldownMs != null && (!Number.isFinite(definition.toggle.cooldownMs) || definition.toggle.cooldownMs < 0))
throw new TypeError(`Cheat "${definition.id}" toggle cooldownMs must be non-negative.`);
if (definition.toggle.maxFailures != null && (!Number.isInteger(definition.toggle.maxFailures) || definition.toggle.maxFailures < 1))
throw new TypeError(
`Cheat "${definition.id}" toggle maxFailures must be a positive integer.`
);
if (definition.toggle.runOnActivate != null && typeof definition.toggle.runOnActivate !== "boolean")
throw new TypeError(`Cheat "${definition.id}" toggle runOnActivate must be boolean.`);
} else if (definition.effect != null)
throw new Error(`Cheat "${definition.id}" effect requires toggle configuration.`);
for (const key of ["sync", "isApplicable", "onEnable", "onDisable", "dispose"])
if (definition[key] != null && typeof definition[key] !== "function")
throw new TypeError(`Cheat "${definition.id}" ${key} must be a function.`);
for (const key of ["requiredPaths", "config"])
if (definition[key] != null) stringArray(definition[key], `Cheat "${definition.id}" ${key}`);
if (definition.diagnostics != null && !plain(definition.diagnostics))
throw new TypeError(`Cheat "${definition.id}" diagnostics must be a plain object.`);
for (const path7 of definition.config ?? [])
if (!CONFIG_PATHS.has(path7))
throw new Error(`Cheat "${definition.id}" references unknown config path "${path7}".`);
if (!Object.keys(definition.actions ?? {}).length && typeof definition.effect !== "function" && typeof definition.sync !== "function")
throw new Error(`Cheat "${definition.id}" requires actions, effect, or sync.`);
return definition;
}
function freezeOwned(value) {
if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
for (const child of Object.values(value)) freezeOwned(child);
return Object.freeze(value);
}
function createCheat(definition) {
validateCheatDefinition(definition);
return freezeOwned(definition);
}
// src/cheat/definitions/developer/run-diagnostics.cheat.js
var revealed = /* @__PURE__ */ new WeakSet();
var lastReports = /* @__PURE__ */ new WeakMap();
function setRevealed(controls, visible) {
for (const key of ["run", "copy", "report"]) controls.element(key).hidden = !visible;
controls.element("reveal").hidden = visible;
if (visible) revealed.add(controls);
else revealed.delete(controls);
}
var runDiagnosticsCheat = createCheat({
id: "developer.run-diagnostics",
location: { section: "misc", group: "developer-tools", order: 1e3 },
meta: {
label: "Developer Tools",
controls: [
{ key: "reveal", type: "button", label: "Show Developer Tools", action: "reveal" },
{ key: "run", type: "button", label: "Run Diagnostics", action: "run" },
{ key: "copy", type: "button", label: "Copy Report", action: "copy" },
{ key: "report", type: "input" }
]
},
actions: {
reveal({ controls }) {
setRevealed(controls, true);
return { ok: true, message: "Developer Tools revealed for this modal." };
},
async run({ controls, services }) {
if (!revealed.has(controls))
return { ok: false, kind: "blocked", message: "Reveal Developer Tools first." };
if (!services.diagnostics?.runAll)
return { ok: false, kind: "blocked", message: "Diagnostics service is unavailable." };
const report = await services.diagnostics.runAll();
const text2 = services.diagnostics.formatReport(report);
lastReports.set(controls, text2);
controls.setValue("report", text2);
return {
ok: report.fail === 0,
kind: report.fail === 0 ? "success" : "validation",
variant: report.fail === 0 ? "success" : "warning",
message: `Diagnostics complete: ${report.pass} pass, ${report.warning} warning, ${report.fail} fail, ${report.blocked} blocked.`
};
},
async copy({ controls }) {
if (!revealed.has(controls))
return { ok: false, kind: "blocked", message: "Reveal Developer Tools first." };
const text2 = lastReports.get(controls) ?? controls.value("report");
if (!text2) return { ok: false, kind: "blocked", message: "Run diagnostics before copying." };
const input = controls.element("report");
const clipboard = input.ownerDocument.defaultView.navigator.clipboard;
if (clipboard?.writeText) {
await clipboard.writeText(text2);
return { ok: true, message: "Diagnostic report copied." };
}
input.hidden = false;
input.focus();
input.select();
return { ok: true, variant: "info", message: "Clipboard unavailable; report selected." };
}
},
onEnable({ controls }) {
setRevealed(controls, false);
},
dispose({ controls }) {
revealed.delete(controls);
lastReports.delete(controls);
},
diagnostics: { developerOnly: true, readOnly: true }
});
// src/cheat/definitions/player/balls.cheat.js
var ballsCheat = createCheat({
id: "player.balls",
location: { section: "stats", group: "player", order: 40 },
meta: {
label: "Balls",
controls: [{ key: "toggle", type: "button", label: "Remove", action: "toggle" }]
},
requiredPaths: ["player.ballsExist"],
refresh: ["mount", "section-open"],
actions: {
toggle({ game }) {
game.set("player.ballsExist", !game.get("player.ballsExist"));
return { ok: true, message: "Balls updated.", refresh: true };
}
},
sync({ game, controls }) {
controls.text("toggle", game.get("player.ballsExist") ? "Remove" : "Add");
}
});
// src/cheat/definitions/player/body-size.cheat.js
var BODY_SIZES = Object.freeze({ Tiny: 0, Small: 1, Normal: 2, Large: 3 });
var BODY_LABELS = Object.freeze(["Tiny", "Small", "Normal", "Large"]);
var bodySizeCheat = createCheat({
id: "player.body-size",
location: { section: "stats", group: "player", order: 20 },
meta: {
label: "Body Size",
controls: [
{ key: "size", type: "select", options: Object.keys(BODY_SIZES) },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["bodysize"],
refresh: ["mount", "section-open", "after-action"],
actions: {
set({ game, controls }) {
const selected = controls.value("size");
if (!Object.hasOwn(BODY_SIZES, selected)) {
return { ok: false, kind: "validation", message: "Unknown body size." };
}
game.set("bodysize", BODY_SIZES[selected]);
return { ok: true, message: "Body size updated." };
}
},
sync({ game, controls }) {
controls.setValue("size", BODY_LABELS[game.get("bodysize")] ?? BODY_LABELS[2]);
}
});
// src/cheat/definitions/player/body-type.cheat.js
var TYPES = Object.freeze({ Masculine: "m", Feminine: "f", Androgynous: "a" });
var LABELS = Object.freeze({ m: "Masculine", f: "Feminine", a: "Androgynous" });
var bodyTypeCheat = createCheat({
id: "player.body-type",
location: { section: "stats", group: "player", order: 30 },
meta: {
label: "Natural Features",
controls: [
{ key: "type", type: "select", options: Object.keys(TYPES) },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["player.gender_body"],
refresh: ["mount", "section-open"],
actions: {
set({ game, controls }) {
const value = TYPES[controls.value("type")];
if (!value) return { ok: false, kind: "validation", message: "Unknown body type." };
game.set("player.gender_body", value);
return { ok: true, message: "Body type updated.", refresh: true };
}
},
sync({ game, controls }) {
controls.setValue("type", LABELS[game.get("player.gender_body")] ?? "Androgynous");
}
});
// src/cheat/data/game-data.js
var releaseSite = "https://github.com/Zenix-Al/DoL-CheatPlus/releases";
var sourceCode = "https://github.com/Zenix-Al/DoL-CheatPlus.git";
var npctrait = ["trust", "love", "dom", "lust", "rage", "trauma", "purity", "corruption"];
var characteristics = [
"beauty",
"purity",
"physique",
"willpower",
"awareness",
"promiscuity",
"exhibitionism",
"deviancy",
"grace",
"submissive",
"masochism",
"sadism"
];
var bodyparts = [
"nipples",
"bottom",
"penis",
"balls",
"clit",
"anus",
"vagina",
"labia",
"left_thigh",
"right_thigh",
"left_foot",
"right_foot",
"left_arm",
"right_arm",
"left_hand",
"right_hand",
"tummy",
"back",
"face",
"mouth",
"left_ear",
"right_ear",
"hair"
];
var parasitename = ["urchin", "slime", "maggot"];
var fame = [
"exhibitionism",
"prostitution",
"bestiality",
"sex",
"rape",
"good",
"business",
"scrap",
"pimp",
"social",
"model",
"pregnancy",
"impreg"
];
var school_rep = ["delinquency", "cool"];
var exam = ["science_exam", "maths_exam", "english_exam", "history_exam"];
var talent_skill = [
"danceskill",
"swimmingskill",
"skulduggery",
"athletics",
"tending",
"housekeeping"
];
var hentaiSkill = [
"seductionskill",
"oralskill",
"vaginalskill",
"analskill",
"handskill",
"feetskill",
"bottomskill",
"thighskill",
"chestskill",
"penileskill"
];
// src/cheat/definitions/player/characteristics.cheat.js
function integer(controls, key) {
return Number.parseInt(controls.value(key), 10);
}
var characteristicsCheat = createCheat({
id: "player.characteristics",
location: { section: "stats", group: "player", order: 80 },
meta: {
label: "Characteristics",
controls: [
{ key: "characteristic", type: "select", options: characteristics, action: "select" },
{ key: "characteristicValue", type: "input" },
{ key: "setCharacteristic", type: "button", label: "Set", action: "setCharacteristic" }
]
},
requiredPaths: [...characteristics],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
setCharacteristic({ game, controls }) {
const value = integer(controls, "characteristicValue");
if (Number.isNaN(value))
return { ok: false, kind: "validation", message: "Input is not a number." };
game.set(controls.value("characteristic"), value);
return { ok: true, message: "Characteristic updated.", refresh: true };
}
},
sync({ game, controls }) {
controls.setValue("characteristicValue", game.get(controls.value("characteristic")));
}
});
// src/cheat/definitions/player/crime.cheat.js
function numericCrimes(game) {
return Object.entries(game.get("crime") ?? {}).filter(
([, crime]) => Number.isFinite(Number.parseInt(crime?.current, 10))
);
}
var crimeCheat = createCheat({
id: "player.crime",
location: { section: "stats", group: "player", order: 60 },
meta: {
label: "Crime",
controls: [
{ key: "current", type: "text", intent: "status" },
{ key: "reduce", type: "button", label: "-100", action: "reduce" },
{ key: "increase", type: "button", label: "+100", action: "increase" }
]
},
requiredPaths: ["crime"],
refresh: ["mount", "section-open"],
actions: {
reduce({ game }) {
const entries2 = numericCrimes(game);
if (!entries2.length) return { ok: false, kind: "blocked", message: "No crime data." };
const value = Number.parseInt(
(entries2.reduce((sum, [, crime]) => sum + Number.parseInt(crime.current, 10), 0) - 100) / entries2.length,
10
);
for (const [key] of entries2) {
for (const field of ["current", "count", "countHistory", "history"])
game.set(`crime.${key}.${field}`, value);
}
return { ok: true, message: "Crime reduced.", refresh: true };
},
increase({ game }) {
const entries2 = numericCrimes(game);
if (!entries2.length) return { ok: false, kind: "blocked", message: "No crime data." };
const value = Number.parseInt(
(entries2.reduce((sum, [, crime]) => sum + Number.parseInt(crime.current, 10), 0) + 100) / entries2.length,
10
);
for (const [key] of entries2) game.set(`crime.${key}.current`, value);
return { ok: true, message: "Crime increased.", refresh: true };
}
},
sync({ game, controls }) {
controls.text(
"current",
numericCrimes(game).reduce((sum, [, crime]) => sum + Number.parseInt(crime.current, 10), 0)
);
}
});
// src/cheat/definitions/player/cum.cheat.js
var cumCheat = createCheat({
id: "player.cum",
location: { section: "stats", group: "player", order: 83 },
meta: {
label: "Cum",
controls: [
{ key: "volume", type: "input", binding: { path: "semen_volume" } },
{ key: "set", type: "button", label: "Set", action: "set" },
{ key: "refill", type: "button", label: "Refill", action: "refill" }
]
},
requiredPaths: ["semen_volume", "semen_amount"],
refresh: ["mount", "section-open"],
actions: {
set({ game, controls }) {
const value = Number.parseInt(controls.value("volume"), 10);
if (Number.isNaN(value))
return { ok: false, kind: "validation", message: "Input is not a number." };
game.set("semen_volume", value);
return { ok: true, message: "Cum volume updated." };
},
refill({ game }) {
game.set("semen_amount", game.get("semen_volume"));
return { ok: true, message: "Cum refilled." };
}
}
});
// src/cheat/definitions/player/editor-helpers.js
function hydrateSelectedValue({ game, controls, path: path7 }) {
controls.setValue("value", game.get(path7(controls.value("field"))) ?? "");
}
function setSelectedNumber({ game, controls, path: path7, label, requireExisting = true }) {
const field = controls.value("field");
const value = Number(controls.value("value"));
if (!field || !Number.isFinite(value))
return { ok: false, kind: "validation", message: `${label} must be a number.` };
const target = path7(field);
if (requireExisting && !game.has(target))
return { ok: false, kind: "validation", message: `${label} is unavailable.` };
game.set(target, value);
return { ok: true, message: `${label} updated.`, refresh: true };
}
function selectAndRefresh() {
return { ok: true, refresh: true };
}
// src/cheat/definitions/player/enemy-stats.cheat.js
var FIELDS2 = ["enemyhealth", "enemytrust", "enemyanger"];
var path = (field) => field;
var enemyStatsCheat = createCheat({
id: "player.enemy-stats",
location: { section: "stats", group: "enemy", order: 1 },
meta: {
label: "Enemy Stats",
controls: [
{ key: "field", type: "select", options: FIELDS2, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: FIELDS2,
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
select: selectAndRefresh,
set(context) {
return setSelectedNumber({ ...context, path, label: "Enemy stat" });
}
},
sync(context) {
hydrateSelectedValue({ ...context, path });
}
});
// src/cheat/definitions/player/exam.cheat.js
var path2 = (field) => field;
var examCheat = createCheat({
id: "player.exam",
location: { section: "stats", group: "school", order: 110 },
meta: {
label: "Exam",
controls: [
{ key: "field", type: "select", options: exam, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: [],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
select: selectAndRefresh,
set(context) {
return setSelectedNumber({
...context,
path: path2,
label: "Exam value",
requireExisting: false
});
}
},
sync(context) {
hydrateSelectedValue({ ...context, path: path2 });
}
});
// src/cheat/definitions/player/fame.cheat.js
var path3 = (field) => `fame.${field}`;
var fameCheat = createCheat({
id: "player.fame",
location: { section: "stats", group: "fame", order: 100 },
meta: {
label: "Fame",
controls: [
{ key: "field", type: "select", options: fame, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["fame"],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
select: selectAndRefresh,
set(context) {
return setSelectedNumber({ ...context, path: path3, label: "Fame" });
}
},
sync(context) {
hydrateSelectedValue({ ...context, path: path3 });
}
});
// src/cheat/definitions/player/hentai-skill.cheat.js
var path4 = (field) => field;
var hentaiSkillCheat = createCheat({
id: "player.hentai-skill",
location: { section: "stats", group: "talent", order: 140 },
meta: {
label: "Hentai Skill",
controls: [
{ key: "field", type: "select", options: hentaiSkill, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: [],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
select: selectAndRefresh,
set(context) {
return setSelectedNumber({
...context,
path: path4,
label: "Hentai skill",
requireExisting: false
});
}
},
sync(context) {
hydrateSelectedValue({ ...context, path: path4 });
}
});
// src/cheat/definitions/player/infinite-arousal.cheat.js
var infiniteArousalCheat = createCheat({
id: "player.infinite-arousal",
location: { section: "quick", group: "unlimited", order: 20 },
meta: {
label: "Unlimited Arousal",
controls: [{ key: "enabled", type: "toggle", label: "Arousal", action: "toggle" }]
},
requiredPaths: ["arousal"],
toggle: { cadence: "frame", cooldownMs: 100, maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("arousal", 1e4);
}
});
// src/cheat/definitions/player/lactation.cheat.js
var lactationCheat = createCheat({
id: "player.lactation",
location: { section: "stats", group: "player", order: 81 },
meta: {
label: "Lactation",
controls: [{ key: "toggle", type: "button", label: "Yes", action: "toggle" }]
},
requiredPaths: ["lactating"],
refresh: ["mount", "section-open"],
actions: {
toggle({ game }) {
game.set("lactating", game.get("lactating") == 1 ? 0 : 1);
return { ok: true, message: "Lactation updated.", refresh: true };
}
},
sync({ game, controls }) {
controls.text("toggle", game.get("lactating") == 1 ? "No" : "Yes");
}
});
// src/cheat/definitions/player/milk.cheat.js
var milkCheat = createCheat({
id: "player.milk",
location: { section: "stats", group: "player", order: 82 },
meta: {
label: "Milk",
controls: [
{ key: "volume", type: "input", binding: { path: "milk_volume" } },
{ key: "set", type: "button", label: "Set", action: "set" },
{ key: "refill", type: "button", label: "Refill", action: "refill" }
]
},
requiredPaths: ["milk_volume", "milk_amount"],
refresh: ["mount", "section-open"],
actions: {
set({ game, controls }) {
const value = Number.parseInt(controls.value("volume"), 10);
if (Number.isNaN(value))
return { ok: false, kind: "validation", message: "Input is not a number." };
game.set("milk_volume", value);
return { ok: true, message: "Milk volume updated." };
},
refill({ game }) {
game.set("milk_amount", game.get("milk_volume"));
return { ok: true, message: "Milk refilled." };
}
}
});
// src/cheat/definitions/player/money.cheat.js
var moneyCheat = createCheat({
id: "player.money",
location: { section: "stats", group: "player", order: 10 },
meta: {
label: "Money",
controls: [
{ key: "value", type: "input", binding: { path: "money", coerce: "number" } },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["money"],
refresh: ["mount", "section-open", "after-action"],
actions: {
set({ game, controls }) {
const value = Number.parseInt(controls.value("value"), 10);
if (Number.isNaN(value)) {
return { ok: false, kind: "validation", message: "Input is not a number." };
}
game.set("money", value);
return { ok: true, message: "Money updated." };
}
}
});
// src/cheat/definitions/player/parasites.cheat.js
var parasitesCheat = createCheat({
id: "player.parasites",
location: { section: "stats", group: "player", order: 70 },
meta: {
label: "Parasite",
controls: [
{ key: "parasite", type: "select", options: parasitename },
{ key: "body", type: "select", options: bodyparts },
{ key: "infect", type: "button", label: "Infect", action: "infect" },
{ key: "remove", type: "button", label: "Remove", action: "remove" }
]
},
requiredPaths: ["parasite"],
actions: {
infect({ game, controls }) {
const parasite = controls.value("parasite");
const body = controls.value("body");
const locations = game.get(`parasite.${parasite}`);
if (!Array.isArray(locations) || game.get(`parasite.${body}`) == null)
return { ok: false, kind: "blocked", message: "Parasite data is unavailable." };
if (!locations.includes(body)) game.set(`parasite.${parasite}`, [...locations, body]);
game.set(`parasite.${body}.name`, parasite);
return { ok: true, message: "Parasite infected." };
},
remove({ game, controls }) {
const parasite = controls.value("parasite");
const body = controls.value("body");
const locations = game.get(`parasite.${parasite}`);
if (!Array.isArray(locations))
return { ok: false, kind: "blocked", message: "Parasite data is unavailable." };
game.set(`parasite.${body}`, []);
game.set(
`parasite.${parasite}`,
locations.filter((item) => item !== body)
);
return { ok: true, message: "Parasite removed." };
}
}
});
// src/cheat/definitions/player/school-reputation.cheat.js
var path5 = (field) => field;
var schoolReputationCheat = createCheat({
id: "player.school-reputation",
location: { section: "stats", group: "school", order: 120 },
meta: {
label: "School Reputation",
controls: [
{ key: "field", type: "select", options: school_rep, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: [],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
select: selectAndRefresh,
set(context) {
return setSelectedNumber({
...context,
path: path5,
label: "School reputation",
requireExisting: false
});
}
},
sync(context) {
hydrateSelectedValue({ ...context, path: path5 });
}
});
// src/cheat/definitions/player/stats.cheat.js
var STATS = Object.freeze([
"pain",
"arousal",
"tiredness",
"stress",
"trauma",
"control",
"drunk",
"drugged",
"hallucinogen"
]);
var playerStatsCheat = createCheat({
id: "player.stats",
location: { section: "stats", group: "player", order: 1 },
meta: {
label: "Player Stats",
controls: [
{ key: "stat", type: "select", options: STATS, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: STATS,
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
set({ game, controls }) {
const value = Number.parseFloat(controls.value("value"));
if (Number.isNaN(value))
return { ok: false, kind: "validation", message: "Value is not a number." };
game.set(controls.value("stat"), value);
return { ok: true, message: "Player stat updated.", refresh: true };
}
},
sync({ game, controls }) {
controls.setValue("value", game.get(controls.value("stat")));
}
});
// src/cheat/definitions/player/talent.cheat.js
var path6 = (field) => field;
var talentCheat = createCheat({
id: "player.talent",
location: { section: "stats", group: "talent", order: 130 },
meta: {
label: "Talent",
controls: [
{ key: "field", type: "select", options: talent_skill, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: [],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
select: selectAndRefresh,
set(context) {
return setSelectedNumber({
...context,
path: path6,
label: "Talent",
requireExisting: false
});
}
},
sync(context) {
hydrateSelectedValue({ ...context, path: path6 });
}
});
// src/cheat/definitions/player/unlimited-spray.cheat.js
var unlimitedSprayCheat = createCheat({
id: "player.unlimited-spray",
location: { section: "stats", group: "player", order: 15 },
meta: {
label: "Unlimited Spray",
controls: [{ key: "toggle", type: "button", label: "Set", action: "toggle" }]
},
requiredPaths: ["infinitespray"],
refresh: ["mount", "section-open"],
actions: {
toggle({ game }) {
game.set("infinitespray", game.get("infinitespray") === 1 ? 0 : 1);
return { ok: true, message: "Unlimited spray updated.", refresh: true };
}
},
sync({ game, controls }) {
controls.text("toggle", game.get("infinitespray") === 1 ? "Unset" : "Set");
}
});
// src/cheat/definitions/player/virginity.cheat.js
var TYPES2 = Object.freeze(["anal", "oral", "penile", "vaginal", "temple", "handholding", "kiss"]);
var virginityCheat = createCheat({
id: "player.virginity",
location: { section: "stats", group: "player", order: 50 },
meta: {
label: "Virginity",
controls: [
{ key: "type", type: "select", options: TYPES2, action: "select" },
{ key: "current", type: "text", intent: "status" },
{ key: "restore", type: "button", label: "Restore", action: "restore" },
{ key: "pure", type: "button", label: "Pure", action: "pure" }
]
},
requiredPaths: ["player.virginity"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
restore({ game, controls }) {
game.set(`player.virginity.${controls.value("type")}`, true);
return { ok: true, message: "Virginity restored.", refresh: true };
},
pure({ game }) {
for (const type of TYPES2) game.set(`player.virginity.${type}`, true);
return { ok: true, message: "Purity applied.", refresh: true };
}
},
sync({ game, controls }) {
controls.text(
"current",
game.get(`player.virginity.${controls.value("type")}`) ? "Pure" : "Taken"
);
}
});
// src/cheat/definitions/quick/arousal.cheat.js
function percentage(controls) {
const value = Number(controls.value("percentage"));
return Number.isFinite(value) ? Math.max(0, Math.min(100, value)) : null;
}
var arousalCheat = createCheat({
id: "quick.arousal",
location: { section: "quick", group: "state", order: 10 },
meta: {
label: "Arousal",
controls: [
{ key: "percentage", type: "range", value: 0, action: "preview", event: "input" },
{ key: "current", type: "text", label: "0%", intent: "status" },
{ key: "player", type: "button", label: "Player", action: "player" },
{ key: "enemy", type: "button", label: "Enemy", action: "enemy" }
]
},
refresh: ["mount", "section-open"],
actions: {
preview() {
return { ok: true, refresh: true };
},
player({ game, controls }) {
const value = percentage(controls);
if (value == null)
return { ok: false, kind: "validation", message: "Arousal must be a number." };
game.set("arousal", Math.trunc(1e4 * value / 100));
return { ok: true, message: "Player arousal updated.", refresh: true };
},
enemy({ game, controls }) {
const value = percentage(controls);
if (value == null)
return { ok: false, kind: "validation", message: "Arousal must be a number." };
game.set("enemyarousal", Math.trunc((game.get("enemyarousalmax") || 0) * value / 100));
return { ok: true, message: "Enemy arousal updated.", refresh: true };
}
},
sync({ controls }) {
controls.text("current", `${controls.value("percentage")}%`);
}
});
// src/cheat/definitions/quick/auto-child-interaction.cheat.js
var autoChildInteractionCheat = createCheat({
id: "quick.auto-child-interaction",
location: { section: "quick", group: "unlimited", order: 90 },
meta: {
label: "Automatic Child Interaction",
controls: [
{
key: "enabled",
type: "toggle",
label: "Auto",
action: "toggle",
tooltip: "You must visit your baby first to trigger automatic interaction."
}
]
},
requiredPaths: ["children"],
toggle: { cadence: "frame", cooldownMs: 200, maxFailures: 5, runOnActivate: true },
effect({ game }) {
for (const child of Object.values(game.get("children") ?? {})) {
const local = child?.localVariables;
if (local?.event !== true) continue;
local.interactions = (local.interactions ?? 0) + 1;
local.interactionsTotal = (local.interactionsTotal ?? 0) + 1;
local.event = false;
}
}
});
// src/cheat/definitions/quick/eden-garden.cheat.js
var edenGardenCheat = createCheat({
id: "quick.eden-garden",
location: { section: "quick", group: "tasks", order: 40 },
meta: {
label: "Eden Garden",
controls: [{ key: "enabled", type: "toggle", label: "Garden", action: "toggle" }]
},
requiredPaths: ["edengarden"],
toggle: { cadence: "daily", maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("edengarden", 4);
}
});
// src/cheat/definitions/quick/eden-mushrooms.cheat.js
var edenMushroomsCheat = createCheat({
id: "quick.eden-mushrooms",
location: { section: "quick", group: "tasks", order: 30 },
meta: {
label: "Eden Mushrooms",
controls: [{ key: "enabled", type: "toggle", label: "Mushrooms", action: "toggle" }]
},
requiredPaths: ["edenshrooms"],
toggle: { cadence: "daily", maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("edenshrooms", 4);
}
});
// src/cheat/definitions/quick/eden-spring.cheat.js
var edenSpringCheat = createCheat({
id: "quick.eden-spring",
location: { section: "quick", group: "tasks", order: 50 },
meta: {
label: "Eden Spring",
controls: [{ key: "enabled", type: "toggle", label: "Spring", action: "toggle" }]
},
requiredPaths: ["edenspring"],
toggle: { cadence: "daily", maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("edenspring", 4);
}
});
// src/cheat/definitions/quick/eden-timer.cheat.js
var edenTimerCheat = createCheat({
id: "quick.eden-timer",
location: { section: "quick", group: "tasks", order: 60 },
meta: {
label: "Eden Timer",
controls: [{ key: "enabled", type: "toggle", label: "Timer", action: "toggle" }]
},
requiredPaths: ["edendays"],
toggle: { cadence: "daily", maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("edendays", 0);
}
});
// src/cheat/definitions/quick/enemy-state.cheat.js
var enemyStateCheat = createCheat({
id: "quick.enemy-state",
location: { section: "quick", group: "state", order: 30 },
meta: {
label: "Enemy State",
controls: [
{ key: "recover", type: "button", label: "Recover", action: "recover" },
{ key: "ruin", type: "button", label: "Ruin", action: "ruin" }
]
},
actions: {
recover({ game }) {
game.set("enemyhealth", Number(game.get("enemyhealthmax")) > 0 ? 100 : 0);
game.set("enemytrust", 100);
game.set("enemyanger", 0);
return { ok: true, message: "Enemy recovered." };
},
ruin({ game }) {
game.set("enemyhealth", 0);
game.set("enemytrust", 100);
game.set("enemyanger", 0);
return { ok: true, message: "Enemy ruined." };
}
}
});
// src/cheat/definitions/quick/everyone-horny.cheat.js
var everyoneHornyCheat = createCheat({
id: "quick.everyone-horny",
location: { section: "quick", group: "unlimited", order: 60 },
meta: {
label: "Everyone Is Horny",
controls: [{ key: "enabled", type: "toggle", label: "Horny", action: "toggle" }]
},
requiredPaths: ["NPCName"],
toggle: { cadence: "frame", cooldownMs: 100, maxFailures: 5, runOnActivate: true },
effect({ game }) {
for (const [index, npc] of (game.get("NPCName") ?? []).entries()) {
if ((npc.nam ?? npc.description) === "Ivory Wraith") continue;
game.set(`NPCName.${index}.lust`, 100);
}
}
});
// src/cheat/definitions/quick/farm-safety.cheat.js
var farmSafetyCheat = createCheat({
id: "quick.farm-safety",
location: { section: "quick", group: "unlimited", order: 70 },
meta: {
label: "Farm Safety",
controls: [{ key: "enabled", type: "toggle", label: "Safe", action: "toggle" }]
},
requiredPaths: ["farm.aggro"],
toggle: { cadence: "frame", cooldownMs: 100, maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("farm.aggro", 0);
}
});
// src/cheat/definitions/quick/game-cheats.cheat.js
function documentOf(controls) {
return controls.element("open").ownerDocument;
}
var gameCheatsCheat = createCheat({
id: "quick.game-cheats",
location: { section: "quick", group: "state", order: 70 },
meta: {
label: "In-game Cheats",
controls: [
{ key: "toggle", type: "button", label: "Enable", action: "toggle" },
{ key: "open", type: "button", label: "Open", action: "open" }
]
},
refresh: ["mount", "section-open", "after-action", "runtime-tick"],
actions: {
toggle({ game }) {
const enabled = game.get("debug") !== 1;
game.set("debug", enabled ? 1 : 0);
return {
ok: true,
message: `In-game cheats ${enabled ? "enabled" : "disabled"}.`,
refresh: true
};
},
open({ game, controls }) {
const button = [
...documentOf(controls).getElementById("overlayButtons")?.querySelectorAll?.(".link-internal") ?? []
].find((candidate) => candidate.textContent?.trim() === "CHEATS");
if (!button) {
return {
ok: false,
kind: "blocked",
message: game.get("debug") === 1 ? "Change passage once, then try opening cheats again." : "Enable in-game cheats first."
};
}
controls.element("open").getRootNode()?.querySelector?.("#close-modal-top")?.click();
button.click();
return { ok: true };
}
},
sync({ game, controls }) {
controls.text("toggle", game.get("debug") === 1 ? "Disable" : "Enable");
}
});
// src/cheat/definitions/quick/hygiene.cheat.js
function fillBodyLiquid(game, amount) {
const bodyLiquid = game.get("player.bodyliquid");
if (!bodyLiquid || typeof bodyLiquid !== "object") return false;
for (const [outer, values] of Object.entries(bodyLiquid)) {
if (!values || typeof values !== "object") continue;
for (const inner of Object.keys(values))
game.set(`player.bodyliquid.${outer}.${inner}`, amount);
}
return true;
}
var hygieneCheat = createCheat({
id: "quick.hygiene",
location: { section: "quick", group: "state", order: 60 },
meta: {
label: "Hygiene",
controls: [
{ key: "clean", type: "button", label: "Clean", action: "clean" },
{ key: "dirty", type: "button", label: "Dirty", action: "dirty" },
{ key: "urethra", type: "button", label: "Clean urethral cum", action: "urethra" }
]
},
actions: {
clean({ game }) {
return fillBodyLiquid(game, 0) ? { ok: true, message: "Body liquids cleaned." } : { ok: false, kind: "validation", message: "Body-liquid data is unavailable." };
},
dirty({ game }) {
return fillBodyLiquid(game, 100) ? { ok: true, message: "Body liquids filled." } : { ok: false, kind: "validation", message: "Body-liquid data is unavailable." };
},
urethra({ game }) {
if (!Array.isArray(game.get("sexStats.vagina.sperm")))
return { ok: false, kind: "validation", message: "Vaginal sperm data is unavailable." };
game.set("sexStats.vagina.sperm", []);
return { ok: true, message: "Urethral cum cleaned." };
}
}
});
// src/cheat/definitions/quick/infinite-npc-pregnancy.cheat.js
var SECONDS_PER_DAY = 86400;
var ACTIVE_LIMIT = 8;
var HARD_LIMIT = 10;
function processNpcPregnancyOverflow({ game, config, feedback }) {
const mainNpcs = game.get("storedNPCs") ?? {};
const mainLength = Object.keys(mainNpcs).length;
const priority = config.get("storedNPCsPriority") || 0;
const currentDate = Math.floor(game.get("timeStamp") / SECONDS_PER_DAY);
const lastDate = config.get("storedNPCsDate");
const elapsedTimerUnits = lastDate !== 0 ? (currentDate - lastDate) * 3 : 0;
if (elapsedTimerUnits === 0) {
if (mainLength <= ACTIVE_LIMIT) return;
if (priority >= ACTIVE_LIMIT) return;
}
const waitingNpcs = { ...config.get("storedNPCs") ?? {} };
const active = {};
const waiting = {};
let activeCount = 0;
config.set("storedNPCsDate", currentDate);
for (const npc of Object.values(mainNpcs)) {
const pregnancy = npc?.pregnancy;
const remaining = pregnancy.timerEnd - pregnancy.timer;
if (remaining <= 3 && activeCount <= ACTIVE_LIMIT) {
active[`stored_${activeCount}`] = npc;
if (activeCount === ACTIVE_LIMIT)
feedback.warning?.("An NPC is about to give birth; pregnancy capacity is full today.");
activeCount += 1;
} else waiting[`stored_${Object.keys(waiting).length}`] = npc;
}
for (const npc of Object.values(waitingNpcs)) {
const pregnancy = npc?.pregnancy;
let timer = pregnancy.timer;
if (elapsedTimerUnits > 0) {
timer = Math.min(pregnancy.timerEnd, timer + elapsedTimerUnits);
pregnancy.timer = timer;
}
const remaining = pregnancy.timerEnd - timer;
if (remaining <= 3 && activeCount <= HARD_LIMIT) {
active[`stored_${activeCount}`] = npc;
if (activeCount === ACTIVE_LIMIT)
feedback.warning?.("An NPC is about to give birth; pregnancy capacity is full today.");
activeCount += 1;
} else waiting[`stored_${Object.keys(waiting).length}`] = npc;
}
config.set("storedNPCsPriority", activeCount);
config.set("storedNPCs", waiting);
game.set("storedNPCs", active);
}
var infiniteNpcPregnancyCheat = createCheat({
id: "quick.infinite-npc-pregnancy",
location: { section: "quick", group: "pregnancy", order: 70 },
meta: {
label: "Infinite NPC Pregnancy",
controls: [
{
key: "enabled",
type: "toggle",
label: "Preserve",
action: "toggle",
tooltip: "Stores overflow pregnancies in CheatPlus until they are one day from birth."
}
]
},
requiredPaths: ["storedNPCs", "timeStamp"],
config: ["storedNPCs", "storedNPCsDate", "storedNPCsPriority"],
toggle: { cadence: "daily", maxFailures: 5, runOnActivate: true },
effect(context) {
processNpcPregnancyOverflow(context);
}
});
// src/cheat/definitions/quick/intense-cum.cheat.js
var temporaryArousal = 0;
var previousOrgasmDown = -1;
var intenseCumCheat = createCheat({
id: "quick.intense-cum",
location: { section: "quick", group: "unlimited", order: 80 },
meta: {
label: "Intense Cum",
controls: [{ key: "enabled", type: "toggle", label: "Intense", action: "toggle" }]
},
requiredPaths: ["orgasmcurrent", "orgasmdown", "arousal"],
config: ["orgasmCount", "unlicumMode"],
toggle: { cadence: "frame", cooldownMs: 80, maxFailures: 5, runOnActivate: true },
effect({ game, config }) {
if (game.get("orgasmcurrent") != 0 && !config.get("unlicumMode")) {
config.set("orgasmCount", 0);
temporaryArousal = game.get("arousal");
game.set("orgasmdown", 1e3);
previousOrgasmDown = 1e3;
config.set("unlicumMode", true);
return;
}
if (game.get("orgasmdown") >= previousOrgasmDown || !config.get("unlicumMode")) return;
previousOrgasmDown = game.get("orgasmdown");
game.set("arousal", temporaryArousal);
const count = config.get("orgasmCount") + 1;
config.set("orgasmCount", count);
if (count <= 2) return;
config.set("unlicumMode", false);
config.set("orgasmCount", 0);
game.set("orgasmdown", -1);
game.set("orgasmcurrent", 0);
previousOrgasmDown = -1;
}
});
// src/cheat/definitions/quick/invincible-angel.cheat.js
var invincibleAngelCheat = createCheat({
id: "quick.invincible-angel",
location: { section: "quick", group: "unlimited", order: 100 },
meta: {
label: "Invincible Angel",
controls: [
{
key: "enabled",
type: "toggle",
label: "Protect",
action: "toggle",
tooltip: "Prevents angel build from falling and helps prevent becoming a fallen angel. Combine it with Maintain Purity."
}
]
},
requiredPaths: ["penisstate", "vaginastate", "angel", "angelbuild"],
config: ["angel", "angelMode"],
toggle: { cadence: "frame", cooldownMs: 100, maxFailures: 1, runOnActivate: true },
effect({ game, config, feedback }) {
if (game.get("demon") > 0) feedback.warning?.("You are currently a demon.");
if (game.get("fallenangel") > 0) {
throw new Error("Invincible Angel is unavailable after becoming a fallen angel.");
}
const transformed = game.get("penisstate") != 0 || game.get("vaginastate") != 0;
if (transformed) {
if (!config.get("angelMode")) return;
config.set("angel", game.get("angel"));
game.set("angel", 0);
game.set("angelbuild", 100);
config.set("angelMode", true);
} else if (!config.get("angelMode")) {
game.set("angel", config.get("angel"));
}
}
});
// src/cheat/definitions/quick/maintain-purity.cheat.js
var maintainPurityCheat = createCheat({
id: "quick.maintain-purity",
location: { section: "quick", group: "unlimited", order: 50 },
meta: {
label: "Maintain Purity",
controls: [{ key: "enabled", type: "toggle", label: "Pure", action: "toggle" }]
},
requiredPaths: ["purity"],
toggle: { cadence: "frame", cooldownMs: 100, maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("purity", 1e3);
}
});
// src/cheat/definitions/quick/maintain-virginity.cheat.js
var maintainVirginityCheat = createCheat({
id: "quick.maintain-virginity",
location: { section: "quick", group: "unlimited", order: 40 },
meta: {
label: "Maintain Virginity",
controls: [{ key: "enabled", type: "toggle", label: "Virgin", action: "toggle" }]
},
requiredPaths: ["player.virginity.penile", "player.virginity.vaginal"],
toggle: { cadence: "frame", cooldownMs: 100, maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("player.virginity.penile", true);
game.set("player.virginity.vaginal", true);
}
});
// src/cheat/definitions/quick/maximum-npc-pregnancy-rate.cheat.js
var maximumNpcPregnancyRateCheat = createCheat({
id: "quick.maximum-npc-pregnancy-rate",
location: { section: "quick", group: "pregnancy", order: 110 },
meta: {
label: "Maximum NPC Pregnancy Rate",
controls: [
{
key: "enabled",
type: "toggle",
label: "Maximum",
action: "toggle",
tooltip: "Gives NPCs the maximum pregnancy rate. Some NPCs still cannot become pregnant; Multiple NPC Pregnancies permits repeated pregnancies."
}
]
},
requiredPaths: ["baseNpcPregnancyChance", "NPCList"],
config: ["baseNpcPregnancyChance"],
toggle: { cadence: "frame", cooldownMs: 250, maxFailures: 5, runOnActivate: true },
effect({ game, config }) {
if (config.get("baseNpcPregnancyChance") === null)
config.set("baseNpcPregnancyChance", game.get("baseNpcPregnancyChance"));
game.set("baseNpcPregnancyChance", 19);
for (const npc of game.get("NPCList")) {
if (npc?.pregnancyAvoidance > 0) npc.pregnancyAvoidance = 0;
}
}
});
// src/cheat/definitions/quick/maximum-stray-tasks.cheat.js
var maximumStrayTasksCheat = createCheat({
id: "quick.maximum-stray-tasks",
location: { section: "quick", group: "tasks", order: 20 },
meta: {
label: "Maximum Stray Tasks",
controls: [{ key: "enabled", type: "toggle", label: "Stray", action: "toggle" }]
},
requiredPaths: ["stray_happiness"],
toggle: { cadence: "daily", maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("stray_happiness", 100);
}
});
// src/cheat/definitions/quick/multiple-npc-pregnancies.cheat.js
var multipleNpcPregnanciesCheat = createCheat({
id: "quick.multiple-npc-pregnancies",
location: { section: "quick", group: "pregnancy", order: 120 },
meta: {
label: "Multiple NPC Pregnancies",
controls: [
{
key: "enabled",
type: "toggle",
label: "Multiple",
action: "toggle",
tooltip: "Allows NPCs to become pregnant multiple times."
}
]
},
requiredPaths: ["NPCList"],
toggle: { cadence: "frame", cooldownMs: 250, maxFailures: 5, runOnActivate: true },
effect({ game }) {
for (const npc of game.get("NPCList")) {
if (npc?.pregnancy === 1) npc.pregnancy = 0;
}
}
});
// src/cheat/definitions/quick/player-state.cheat.js
var RECOVERED = Object.freeze({
pain: 0,
arousal: 0,
tiredness: 0,
stress: 0,
trauma: 0,
control: 1e3,
drunk: 0,
drugged: 0,
hallucinogen: 0
});
var RUINED = Object.freeze({
pain: 200,
arousal: 1e4,
tiredness: 2e3,
stress: 1e4,
trauma: 5e3,
control: 0,
drunk: 1e3,
drugged: 1e3,
hallucinogen: 1e3
});
function applyValues(game, values) {
for (const [path7, value] of Object.entries(values)) game.set(path7, value);
}
var playerStateCheat = createCheat({
id: "quick.player-state",
location: { section: "quick", group: "state", order: 1 },
meta: {
label: "Player State",
controls: [
{ key: "recover", type: "button", label: "Recover", action: "recover" },
{ key: "ruin", type: "button", label: "Ruin", action: "ruin" }
]
},
requiredPaths: Object.keys(RECOVERED),
actions: {
recover({ game }) {
applyValues(game, RECOVERED);
return { ok: true, message: "Player recovered." };
},
ruin({ game }) {
applyValues(game, RUINED);
return { ok: true, message: "Player ruined." };
}
}
});
// src/cheat/definitions/quick/pregnancy-detection.cheat.js
var previousNpcCount = 0;
var previousPlayerCount = 0;
function npcCount(game, config) {
let total = Object.keys(game.get("storedNPCs") ?? {}).length;
total += Object.keys(config.get("storedNPCs") ?? {}).length;
for (const npc of game.get("NPCName") ?? []) {
if (npc?.pregnancy?.fetus?.length > 0) total += 1;
}
return total;
}
function playerCount(game) {
return (game.get("sexStats.vagina.pregnancy.fetus")?.length ?? 0) + (game.get("sexStats.anus.pregnancy.fetus")?.length ?? 0);
}
var pregnancyDetectionCheat = createCheat({
id: "quick.pregnancy-detection",
location: { section: "quick", group: "pregnancy", order: 100 },
meta: {
label: "Pregnancy Detection",
controls: [{ key: "enabled", type: "toggle", label: "Detect", action: "toggle" }]
},
requiredPaths: ["storedNPCs", "NPCName", "sexStats", "timeStamp"],
config: ["storedNPCs", "storedNPCsDate", "storedNPCsPriority"],
toggle: { cadence: "frame", cooldownMs: 250, maxFailures: 5, runOnActivate: true },
onEnable() {
previousNpcCount = 0;
previousPlayerCount = 0;
},
effect(context) {
const nextNpcCount = npcCount(context.game, context.config);
const nextPlayerCount = playerCount(context.game);
if (previousNpcCount === 0) {
previousNpcCount = nextNpcCount;
previousPlayerCount = nextPlayerCount;
return;
}
if (nextNpcCount !== previousNpcCount) {
context.feedback.info?.(
nextNpcCount > previousNpcCount ? "An NPC became pregnant." : "An NPC gave birth."
);
processNpcPregnancyOverflow(context);
previousNpcCount = nextNpcCount;
}
if (nextPlayerCount !== previousPlayerCount) {
context.feedback.info?.(
nextPlayerCount > previousPlayerCount ? "The player became pregnant." : "The player gave birth."
);
previousPlayerCount = nextPlayerCount;
}
}
});
// src/cheat/definitions/quick/random-encounters.cheat.js
var randomEncountersCheat = createCheat({
id: "quick.random-encounters",
location: { section: "quick", group: "state", order: 80 },
meta: {
label: "Random Encounters",
controls: [{ key: "toggle", type: "button", label: "Enable", action: "toggle" }]
},
refresh: ["mount", "section-open", "after-action", "runtime-tick"],
actions: {
toggle({ game }) {
const enabled = game.get("alluremod") === 0;
game.set("alluremod", enabled ? 1 : 0);
return {
ok: true,
message: `Random encounters ${enabled ? "enabled" : "disabled"}.`,
refresh: true
};
}
},
sync({ game, controls }) {
controls.text("toggle", game.get("alluremod") === 1 ? "Enabled" : "Disabled");
}
});
// src/cheat/definitions/quick/temple-vow.cheat.js
var templeVowCheat = createCheat({
id: "quick.temple-vow",
location: { section: "quick", group: "state", order: 50 },
meta: {
label: "Temple Vow",
controls: [
{ key: "toggle", type: "button", label: "Toggle", action: "toggle" },
{ key: "current", type: "text", label: "", intent: "status" }
]
},
requiredPaths: ["player.virginity.temple"],
refresh: ["mount", "section-open", "after-action", "runtime-tick"],
actions: {
toggle({ game }) {
game.set("player.virginity.temple", !game.get("player.virginity.temple"));
return { ok: true, message: "Temple vow updated.", refresh: true };
}
},
sync({ game, controls }) {
controls.text("current", game.get("player.virginity.temple") ? "Virgin" : "Not virgin");
}
});
// src/cheat/definitions/quick/unlimited-cum.cheat.js
var unlimitedCumCheat = createCheat({
id: "quick.unlimited-cum",
location: { section: "quick", group: "unlimited", order: 30 },
meta: {
label: "Unlimited Cum",
controls: [{ key: "enabled", type: "toggle", label: "Cum", action: "toggle" }]
},
requiredPaths: ["semen_amount", "semen_volume", "orgasmcount"],
toggle: { cadence: "frame", cooldownMs: 100, maxFailures: 5, runOnActivate: true },
effect({ game }) {
if (game.get("semen_amount") >= game.get("semen_volume")) return;
game.set("semen_amount", game.get("semen_volume"));
game.set("orgasmcount", 0);
}
});
// src/cheat/definitions/world/farm-editor-helpers.js
function hydrateInput({ game, controls, control = "value", path: path7 }) {
controls.setValue(control, game.get(path7) ?? "");
}
function setInteger({ game, controls, path: path7, label, control = "value" }) {
const raw = controls.value(control);
const value = Number(raw);
if (String(raw).trim() === "" || !Number.isInteger(value))
return { ok: false, kind: "validation", message: `${label} must be an integer.` };
if (!game.has(path7))
return { ok: false, kind: "validation", message: `${label} is unavailable.` };
game.set(path7, value);
return { ok: true, message: `${label} updated.`, refresh: true };
}
function selectAndRefresh2() {
return { ok: true, refresh: true };
}
// src/cheat/definitions/world/farm-animal-affinity.cheat.js
function animalOptions({ game }) {
return Object.keys(game.get("farm.beasts") ?? {}).sort(
(left, right) => left.localeCompare(right)
);
}
var selectedPath = (controls) => `farm.beasts.${controls.value("animal")}`;
var farmAnimalAffinityCheat = createCheat({
id: "world.farm-animal-affinity",
location: { section: "misc", group: "farm", order: 100 },
meta: {
label: "Farm Animal Affinity",
controls: [
{ key: "animal", type: "select", options: animalOptions, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["farm.beasts"],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
select: selectAndRefresh2,
set({ game, controls }) {
return setInteger({
game,
controls,
path: selectedPath(controls),
label: "Animal affinity"
});
}
},
sync({ game, controls }) {
hydrateInput({ game, controls, path: selectedPath(controls) });
}
});
// src/cheat/definitions/world/farm-assault-time.cheat.js
var PATH = "farm_attack_timer";
var farmAssaultTimeCheat = createCheat({
id: "world.farm-assault-time",
location: { section: "misc", group: "farm", order: 120 },
meta: {
label: "Farm Assault Time",
controls: [
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: [PATH],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
set({ game, controls }) {
return setInteger({ game, controls, path: PATH, label: "Farm assault time" });
}
},
sync({ game, controls }) {
hydrateInput({ game, controls, path: PATH });
}
});
// src/cheat/definitions/world/farm-build-time.cheat.js
var PATH2 = "farm.build_timer";
var farmBuildTimeCheat = createCheat({
id: "world.farm-build-time",
location: { section: "misc", group: "farm", order: 110 },
meta: {
label: "Farm Build Time",
controls: [
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: [PATH2],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
set({ game, controls }) {
return setInteger({ game, controls, path: PATH2, label: "Farm build time" });
}
},
sync({ game, controls }) {
hydrateInput({ game, controls, path: PATH2 });
}
});
// src/cheat/definitions/world/max-harmony.cheat.js
var maxHarmonyCheat = createCheat({
id: "world.max-harmony",
location: { section: "misc", group: "world", order: 10 },
meta: {
label: "Wolfpack",
controls: [
{ key: "harmony", type: "button", label: "Max Harmony", action: "harmony" },
{ key: "ferocity", type: "button", label: "Max Ferocity", action: "ferocity" }
]
},
actions: {
harmony({ game }) {
game.set("wolfpackharmony", 22);
return { ok: true, message: "Wolfpack harmony maximized." };
},
ferocity({ game }) {
game.set("wolfpackferocity", 22);
return { ok: true, message: "Wolfpack ferocity maximized." };
}
}
});
// src/cheat/definitions/world/maximum-church-tasks.cheat.js
var maximumChurchTasksCheat = createCheat({
id: "world.maximum-church-tasks",
location: { section: "quick", group: "tasks", order: 10 },
meta: {
label: "Maximum Church Tasks",
controls: [{ key: "enabled", type: "toggle", label: "Church", action: "toggle" }]
},
requiredPaths: ["temple_garden", "temple_quarters", "grace"],
toggle: { cadence: "daily", maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("temple_garden", 100);
game.set("temple_quarters", 100);
game.set("grace", 100);
}
});
// src/cheat/definitions/world/pregnancy-editor-helpers.js
var confirmed = (controls) => controls.checked("confirm");
function fetusOptions(pregnancy) {
return (pregnancy?.fetus ?? []).map((fetus, index) => ({
value: index,
label: fetus?.name ?? fetus?.mother ?? fetus?.creature ?? fetus?.stats?.gender ?? `Fetus ${index + 1}`
}));
}
function resetPregnancy(pregnancy) {
pregnancy.fetus = [];
pregnancy.potentialFathers = [];
pregnancy.timer = 0;
pregnancy.timerEnd = null;
pregnancy.type = null;
pregnancy.waterBreaking = false;
pregnancy.waterBreakingTimer = null;
if ("awareOf" in pregnancy) pregnancy.awareOf = null;
if ("awareOfDetails" in pregnancy) pregnancy.awareOfDetails = null;
if ("awareOfMultiple" in pregnancy) pregnancy.awareOfMultiple = null;
}
function removeFetus(pregnancy, selected) {
if (!Array.isArray(pregnancy?.fetus) || pregnancy.fetus.length === 0) return false;
if (pregnancy.fetus.length === 1) resetPregnancy(pregnancy);
else pregnancy.fetus.splice(Number.parseInt(selected, 10), 1);
return true;
}
var destructiveConfirmation = "Confirm removal. Pregnancy and child deletion cannot be undone.";
// src/cheat/definitions/world/mc-abortion.cheat.js
function locationOptions({ game }) {
return Object.entries(game.get("sexStats") ?? {}).filter(([, value]) => Array.isArray(value?.pregnancy?.fetus)).map(([key]) => key);
}
function options({ game, controls }) {
return fetusOptions(game.get(`sexStats.${controls.value("location")}.pregnancy`));
}
var mcAbortionCheat = createCheat({
id: "world.mc-abortion",
location: { section: "misc", group: "pregnancy-removal", order: 70 },
meta: {
label: "MC Pregnancy Removal",
controls: [
{ key: "location", type: "select", options: locationOptions, action: "select" },
{ key: "fetus", type: "select", options, action: "select" },
{ key: "confirm", type: "toggle", label: "Confirm", intent: "confirmation" },
{ key: "remove", type: "button", label: "Remove", action: "remove" }
]
},
requiredPaths: ["sexStats"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
remove({ game, controls }) {
if (!confirmed(controls))
return { ok: false, kind: "blocked", message: destructiveConfirmation };
const path7 = `sexStats.${controls.value("location")}.pregnancy`;
const pregnancy = game.get(path7);
if (!removeFetus(pregnancy, controls.value("fetus")))
return { ok: false, kind: "validation", message: "No fetus is available." };
game.set(path7, pregnancy);
controls.setValue("confirm", false);
return { ok: true, message: "MC pregnancy removed.", refresh: true };
}
}
});
// src/cheat/definitions/world/mc-child-manager.cheat.js
var PROPERTIES = [
{ value: "name", label: "Name" },
{ value: "motherKnown", label: "Mother Known" },
{ value: "fatherKnown", label: "Father Known" },
{ value: "abandon", label: "Abandon Selected" }
];
function childOptions({ game }) {
return Object.entries(game.get("children") ?? {}).map(([key, child]) => ({
value: key,
label: child?.name ?? key
}));
}
function selectedChild({ game, controls }) {
const key = controls.value("child");
return key ? game.get(`children.${key}`) : void 0;
}
function setChildControlsVisible(controls, visible) {
for (const key of ["property", "value", "summary", "confirm", "set", "purge"]) {
controls.element(key).closest(".cp-cheat-control-unit").hidden = !visible;
}
}
var mcChildManagerCheat = createCheat({
id: "world.mc-child-manager",
location: { section: "misc", group: "offspring", order: 60 },
meta: {
label: "MC Child Manager",
controls: [
{
key: "child",
type: "select",
options: childOptions,
fallbackOptions: [{ value: "", label: "No children" }],
action: "select"
},
{ key: "property", type: "select", options: PROPERTIES, action: "select" },
{ key: "value", type: "input" },
{ key: "summary", type: "text" },
{ key: "confirm", type: "toggle", label: "Confirm deletion", intent: "confirmation" },
{ key: "set", type: "button", label: "Apply", action: "set" },
{ key: "purge", type: "button", label: "Abandon All", action: "purge" }
]
},
requiredPaths: ["children"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
set({ game, controls }) {
const key = controls.value("child");
const property = controls.value("property");
if (!key || !selectedChild({ game, controls }))
return { ok: false, kind: "validation", message: "Select an existing child." };
if (property === "abandon") {
if (!controls.checked("confirm"))
return { ok: false, kind: "blocked", message: destructiveConfirmation };
const children = { ...game.get("children") ?? {} };
delete children[key];
game.set("children", children);
controls.setValue("confirm", false);
return { ok: true, message: "Child abandoned.", refresh: true };
}
const input = controls.element("value");
const value = property === "name" ? controls.value("value") : Boolean(input.checked);
game.set(`children.${key}.${property}`, value);
return { ok: true, message: "Child information updated.", refresh: true };
},
purge({ game, controls }) {
if (!controls.checked("confirm"))
return { ok: false, kind: "blocked", message: destructiveConfirmation };
game.set("children", {});
controls.setValue("confirm", false);
return { ok: true, message: "All children abandoned.", refresh: true };
}
},
sync(context) {
const child = selectedChild(context);
setChildControlsVisible(context.controls, Boolean(child));
if (!child) return;
const property = context.controls.value("property");
const input = context.controls.element("value");
const booleanInput = property !== "name";
input.type = booleanInput ? "checkbox" : "text";
if (booleanInput) input.checked = property === "abandon" ? false : Boolean(child?.[property]);
else context.controls.setValue("value", child?.name ?? "");
context.controls.text(
"summary",
`${child.name ?? ""} \xB7 ${child.mother ?? "unknown mother"} \xB7 ${child.father ?? "unknown father"} \xB7 ${child.birthLocation ?? "unknown location"}`
);
}
});
// src/cheat/definitions/world/mc-pregnancy.cheat.js
var LOCK_JOB_ID = "world.mc-pregnancy.lock";
var lockedDays = /* @__PURE__ */ new Map();
function holeOptions({ game }) {
return Object.entries(game.get("sexStats") ?? {}).filter(([, value]) => value?.pregnancy).map(([key]) => key);
}
function pregnancyOptions({ game, controls }) {
const pregnancy = game.get(`sexStats.${controls.value("hole")}.pregnancy`);
if (pregnancy?.type === "parasite") {
return Object.entries(pregnancy.fetus ?? {}).map(([key, fetus]) => ({
value: key,
label: fetus?.creature ?? key
}));
}
return pregnancy?.timerEnd != null ? [{ value: "baby", label: "Baby" }] : [];
}
function lockKey(hole, type, pregnancy) {
return `${hole}:${type ?? "pregnancy"}:${pregnancy}`;
}
function applyDays(game, { hole, pregnancy: selected, days }) {
const pregnancy = game.get(`sexStats.${hole}.pregnancy`);
if (!pregnancy) return false;
if (pregnancy.type === "parasite") {
if (!pregnancy.fetus?.[selected]) return false;
game.set(`sexStats.${hole}.pregnancy.fetus.${selected}.daysLeft`, days);
} else {
if (!Number.isFinite(pregnancy.timerEnd)) return false;
game.set(`sexStats.${hole}.pregnancy.timer`, Math.max(0, pregnancy.timerEnd - days * 3));
}
return true;
}
function syncSchedule({ game, services }) {
services.scheduler?.unregister(LOCK_JOB_ID, { cadence: "frame" });
if (!lockedDays.size) return;
services.scheduler?.register(
LOCK_JOB_ID,
() => {
for (const lock of lockedDays.values()) applyDays(game, lock);
},
{ cadence: "frame", cooldownMs: 100, maxFailures: 5 }
);
}
var mcPregnancyCheat = createCheat({
id: "world.mc-pregnancy",
location: { section: "misc", group: "pregnancy", order: 40 },
meta: {
label: "MC Pregnancy",
controls: [
{ key: "hole", type: "select", options: holeOptions, action: "select" },
{ key: "pregnancy", type: "select", options: pregnancyOptions, action: "select" },
{ key: "days", type: "input" },
{ key: "locked", type: "toggle", label: "Lock pregnancy" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["sexStats"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
set(context) {
const hole = context.controls.value("hole");
const selected = context.controls.value("pregnancy");
const days = Number.parseInt(context.controls.value("days"), 10);
const type = context.game.get(`sexStats.${hole}.pregnancy.type`);
if (!hole || !selected || Number.isNaN(days) || !applyDays(context.game, { hole, pregnancy: selected, days }))
return { ok: false, kind: "validation", message: "MC pregnancy data is unavailable." };
const key = lockKey(hole, type, selected);
if (context.controls.checked("locked"))
lockedDays.set(key, { hole, pregnancy: selected, days });
else lockedDays.delete(key);
syncSchedule(context);
return { ok: true, message: "MC pregnancy updated.", refresh: true };
}
},
sync({ game, controls }) {
const hole = controls.value("hole");
const selected = controls.value("pregnancy");
const pregnancy = game.get(`sexStats.${hole}.pregnancy`);
const days = pregnancy?.type === "parasite" ? pregnancy?.fetus?.[selected]?.daysLeft : Number.isFinite(pregnancy?.timerEnd - pregnancy?.timer) ? (pregnancy.timerEnd - pregnancy.timer) / 3 : "";
controls.setValue("days", days ?? "");
controls.setValue("locked", lockedDays.has(lockKey(hole, pregnancy?.type, selected)));
},
onEnable(context) {
syncSchedule(context);
return () => context.services.scheduler?.unregister(LOCK_JOB_ID, { cadence: "frame" });
}
});
// src/cheat/definitions/world/mc-tentacle.cheat.js
function locationOptions2({ game }) {
return Object.entries(game.get("container") ?? {}).filter(([, value]) => value?.creatures).map(([key]) => key);
}
function creatureOptions({ game, controls }) {
return Object.entries(game.get(`container.${controls.value("location")}.creatures`) ?? {}).filter(([, creature]) => creature).map(([key, creature]) => ({ value: key, label: creature.creature ?? key }));
}
var mcTentacleCheat = createCheat({
id: "world.mc-tentacle",
location: { section: "misc", group: "offspring", order: 50 },
meta: {
label: "MC Tentacle Pregnancy",
controls: [
{ key: "location", type: "select", options: locationOptions2, action: "select" },
{ key: "creature", type: "select", options: creatureOptions, action: "select" },
{ key: "speed", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["container"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
set({ game, controls }) {
const path7 = `container.${controls.value("location")}.creatures.${controls.value(
"creature"
)}.stats.speed`;
const speed = Number.parseInt(controls.value("speed"), 10);
if (!game.has(path7) || Number.isNaN(speed))
return { ok: false, kind: "validation", message: "Tentacle data is unavailable." };
game.set(path7, speed);
return { ok: true, message: "Tentacle pregnancy speed updated.", refresh: true };
}
},
sync({ game, controls }) {
controls.setValue(
"speed",
game.get(
`container.${controls.value("location")}.creatures.${controls.value(
"creature"
)}.stats.speed`
) ?? ""
);
}
});
// src/cheat/definitions/world/named-npc-abortion.cheat.js
function npcOptions({ game }) {
return (game.get("NPCName") ?? []).map((npc, index) => ({ npc, index })).filter(({ npc }) => Array.isArray(npc?.pregnancy?.fetus)).map(({ npc, index }) => ({ value: index, label: npc.nam ?? npc.description ?? index }));
}
function options2({ game, controls }) {
return fetusOptions(game.get(`NPCName.${controls.value("npc")}.pregnancy`));
}
var namedNpcAbortionCheat = createCheat({
id: "world.named-npc-abortion",
location: { section: "misc", group: "pregnancy-removal", order: 80 },
meta: {
label: "Named NPC Pregnancy Removal",
controls: [
{ key: "npc", type: "select", options: npcOptions, action: "select" },
{ key: "fetus", type: "select", options: options2, action: "select" },
{ key: "confirm", type: "toggle", label: "Confirm", intent: "confirmation" },
{ key: "remove", type: "button", label: "Remove", action: "remove" }
]
},
requiredPaths: ["NPCName"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
remove({ game, controls }) {
if (!confirmed(controls))
return { ok: false, kind: "blocked", message: destructiveConfirmation };
const path7 = `NPCName.${controls.value("npc")}.pregnancy`;
const pregnancy = game.get(path7);
if (!removeFetus(pregnancy, controls.value("fetus")))
return { ok: false, kind: "validation", message: "No fetus is available." };
game.set(path7, pregnancy);
controls.setValue("confirm", false);
return { ok: true, message: "Named NPC pregnancy removed.", refresh: true };
}
}
});
// src/cheat/definitions/world/named-npc-pregnancy.cheat.js
var LOCK_JOB_ID2 = "world.named-npc-pregnancy.lock";
var lockedDays2 = /* @__PURE__ */ new Map();
function options3({ game }) {
return (game.get("NPCName") ?? []).map((npc, index) => ({ npc, index })).filter(({ npc }) => npc?.pregnancy?.timer != null).map(({ npc, index }) => ({ value: index, label: npc.nam ?? npc.description }));
}
function applyLocks(game) {
for (const [index, days] of lockedDays2) {
const timerEnd = game.get(`NPCName.${index}.pregnancy.timerEnd`);
if (!Number.isFinite(timerEnd)) continue;
game.set(`NPCName.${index}.pregnancy.timer`, Math.max(0, timerEnd - days * 3));
}
}
function syncSchedule2({ game, services }) {
services.scheduler?.unregister(LOCK_JOB_ID2, { cadence: "frame" });
if (!lockedDays2.size) return;
services.scheduler?.register(LOCK_JOB_ID2, () => applyLocks(game), {
cadence: "frame",
cooldownMs: 100,
maxFailures: 5
});
}
var namedNpcPregnancyCheat = createCheat({
id: "world.named-npc-pregnancy",
location: { section: "misc", group: "pregnancy", order: 20 },
meta: {
label: "Named NPC Pregnancy",
controls: [
{
key: "npc",
type: "select",
options: options3,
fallbackOptions: [{ value: "", label: "No pregnancies" }],
action: "select"
},
{ key: "days", type: "input" },
{ key: "locked", type: "toggle", label: "Lock pregnancy" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["NPCName"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
set(context) {
const index = Number.parseInt(context.controls.value("npc"), 10);
const days = Number.parseInt(context.controls.value("days"), 10);
const timerEnd = context.game.get(`NPCName.${index}.pregnancy.timerEnd`);
if (!Number.isInteger(index) || Number.isNaN(days) || !Number.isFinite(timerEnd))
return { ok: false, kind: "validation", message: "Pregnancy data is unavailable." };
if (context.controls.checked("locked")) lockedDays2.set(index, days);
else lockedDays2.delete(index);
context.game.set(`NPCName.${index}.pregnancy.timer`, Math.max(0, timerEnd - days * 3));
syncSchedule2(context);
return { ok: true, message: "Named NPC pregnancy updated.", refresh: true };
}
},
sync({ game, controls }) {
const index = Number.parseInt(controls.value("npc"), 10);
const timer = game.get(`NPCName.${index}.pregnancy.timer`);
const timerEnd = game.get(`NPCName.${index}.pregnancy.timerEnd`);
controls.setValue("days", Number.isFinite(timerEnd - timer) ? (timerEnd - timer) / 3 : "");
controls.setValue("locked", lockedDays2.has(index));
},
onEnable(context) {
syncSchedule2(context);
return () => context.services.scheduler?.unregister(LOCK_JOB_ID2, { cadence: "frame" });
}
});
// src/cheat/definitions/world/npc-trait-editor.cheat.js
function npcOptions2({ game }) {
const configured = game.setup("NPCNameList");
const names = Array.isArray(configured) ? configured : (game.get("NPCName") ?? []).map(({ nam, description }) => nam ?? description);
return names.map((name) => ({ value: name, label: name }));
}
function selectedNpc({ game, controls }) {
const list = game.get("NPCName") ?? [];
const selectedName = controls.value("npc");
const index = list.findIndex(
({ nam, description }) => nam === selectedName || description === selectedName
);
return { index, npc: list[index] };
}
var npcTraitEditorCheat = createCheat({
id: "world.npc-trait-editor",
location: { section: "misc", group: "npc", order: 5 },
meta: {
label: "NPC Manager",
controls: [
{
key: "npc",
type: "select",
options: npcOptions2,
fallbackOptions: [{ value: "", label: "No NPC data" }],
action: "select"
},
{ key: "trait", type: "select", options: npctrait, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["NPCName"],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
select() {
return { ok: true, refresh: true };
},
set(context) {
const { index, npc } = selectedNpc(context);
const trait = context.controls.value("trait");
const value = Number.parseInt(context.controls.value("value"), 10);
if (!npc || !Object.hasOwn(npc, trait))
return { ok: false, kind: "validation", message: "NPC trait is unavailable." };
if (Number.isNaN(value))
return { ok: false, kind: "validation", message: "Input is not a number." };
context.game.set(`NPCName.${index}.${trait}`, value);
return { ok: true, message: "NPC trait updated.", refresh: true };
}
},
sync(context) {
const { npc } = selectedNpc(context);
const trait = context.controls.value("trait");
context.controls.setValue("value", npc?.[trait] ?? "");
}
});
// src/cheat/definitions/world/produce-sales-report.cheat.js
function sellingEntries(game) {
return Object.entries(game.get("farmersProduce.selling") ?? {}).map(([name, raw]) => ({ name, amount: Number(raw) })).filter(({ amount }) => Number.isFinite(amount)).sort((left, right) => right.amount - left.amount || left.name.localeCompare(right.name));
}
function renderReport({ game, controls }) {
const entries2 = sellingEntries(game);
controls.text(
"report",
entries2.length ? entries2.map(({ name, amount }, index) => `${index + 1}. ${name}: ${amount}`).join(" | ") : "No produce sales recorded."
);
}
var produceSalesReportCheat = createCheat({
id: "world.produce-sales-report",
location: { section: "misc", group: "produce-inspection", order: 130 },
meta: {
label: "Produce Sales",
controls: [
{ key: "report", type: "text" },
{ key: "refresh", type: "button", label: "Refresh", action: "refresh" }
]
},
requiredPaths: ["farmersProduce.selling"],
isApplicable({ game }) {
const selling = game.get("farmersProduce.selling");
return Boolean(selling) && typeof selling === "object" && !Array.isArray(selling);
},
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
refresh() {
return { ok: true, message: "Produce sales refreshed.", refresh: true };
}
},
sync: renderReport
});
// src/cheat/definitions/world/stored-npc-abortion.cheat.js
function entries(context) {
const gameEntries = Object.entries(context.game.get("storedNPCs") ?? {}).map(([key, npc]) => ({
source: "game",
key,
npc
}));
const configEntries = Object.entries(context.config.get("storedNPCs") ?? {}).map(
([key, npc]) => ({ source: "config", key, npc })
);
return [...gameEntries, ...configEntries].filter(
({ npc }) => Array.isArray(npc?.pregnancy?.fetus)
);
}
function npcOptions3(context) {
return entries(context).map(({ source, key, npc }, index) => ({
value: `${source}:${key}`,
label: `${index + 1}. ${npc.pregnancy.fetus[0]?.mother ?? key}`
}));
}
function selection(context) {
const [source, ...keyParts] = context.controls.value("npc").split(":");
const key = keyParts.join(":");
const store2 = source === "config" ? context.config.get("storedNPCs") : context.game.get("storedNPCs");
return { source, key, store: store2 ?? {}, npc: store2?.[key] };
}
function options4(context) {
return fetusOptions(selection(context).npc?.pregnancy);
}
var storedNpcAbortionCheat = createCheat({
id: "world.stored-npc-abortion",
location: { section: "misc", group: "pregnancy-removal", order: 90 },
meta: {
label: "Stored NPC Pregnancy Removal",
controls: [
{ key: "npc", type: "select", options: npcOptions3, action: "select" },
{ key: "fetus", type: "select", options: options4, action: "select" },
{ key: "confirm", type: "toggle", label: "Confirm", intent: "confirmation" },
{ key: "remove", type: "button", label: "Remove", action: "remove" },
{ key: "purge", type: "button", label: "Purge All", action: "purge" }
]
},
requiredPaths: ["storedNPCs"],
config: ["storedNPCs"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
remove(context) {
if (!confirmed(context.controls))
return { ok: false, kind: "blocked", message: destructiveConfirmation };
const { source, key, store: store2, npc } = selection(context);
if (!key || !removeFetus(npc?.pregnancy, context.controls.value("fetus")))
return { ok: false, kind: "validation", message: "No fetus is available." };
if (npc.pregnancy.fetus.length === 0) delete store2[key];
if (source === "config") context.config.set("storedNPCs", { ...store2 });
else context.game.set("storedNPCs", { ...store2 });
context.controls.setValue("confirm", false);
return { ok: true, message: "Stored NPC pregnancy removed.", refresh: true };
},
purge(context) {
if (!confirmed(context.controls))
return { ok: false, kind: "blocked", message: destructiveConfirmation };
context.game.set("storedNPCs", {});
context.config.set("storedNPCs", {});
context.controls.setValue("confirm", false);
return { ok: true, message: "Stored NPC pregnancies purged.", refresh: true };
}
}
});
// src/cheat/definitions/world/stored-npc-pregnancy.cheat.js
var LOCK_JOB_ID3 = "world.stored-npc-pregnancy.lock";
var lockedDays3 = /* @__PURE__ */ new Map();
function options5({ game }) {
return Object.entries(game.get("storedNPCs") ?? {}).filter(([, npc]) => npc?.pregnancy?.fetus?.[0]?.mother).map(([key, npc]) => ({ value: key, label: npc.pregnancy.fetus[0].mother }));
}
function applyLocks2(game) {
for (const [key, days] of lockedDays3) {
const timerEnd = game.get(`storedNPCs.${key}.pregnancy.timerEnd`);
if (!Number.isFinite(timerEnd)) continue;
game.set(`storedNPCs.${key}.pregnancy.timer`, Math.max(0, timerEnd - days * 3));
}
}
function syncSchedule3({ game, services }) {
services.scheduler?.unregister(LOCK_JOB_ID3, { cadence: "frame" });
if (!lockedDays3.size) return;
services.scheduler?.register(LOCK_JOB_ID3, () => applyLocks2(game), {
cadence: "frame",
cooldownMs: 100,
maxFailures: 5
});
}
var storedNpcPregnancyCheat = createCheat({
id: "world.stored-npc-pregnancy",
location: { section: "misc", group: "pregnancy", order: 30 },
meta: {
label: "NPC Pregnancy",
controls: [
{
key: "npc",
type: "select",
options: options5,
fallbackOptions: [{ value: "", label: "No pregnancies" }],
action: "select"
},
{ key: "days", type: "input" },
{ key: "locked", type: "toggle", label: "Lock pregnancy" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["storedNPCs"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
set(context) {
const key = context.controls.value("npc");
const days = Number.parseInt(context.controls.value("days"), 10);
const timerEnd = context.game.get(`storedNPCs.${key}.pregnancy.timerEnd`);
if (!key || Number.isNaN(days) || !Number.isFinite(timerEnd))
return { ok: false, kind: "validation", message: "Pregnancy data is unavailable." };
if (context.controls.checked("locked")) lockedDays3.set(key, days);
else lockedDays3.delete(key);
context.game.set(`storedNPCs.${key}.pregnancy.timer`, Math.max(0, timerEnd - days * 3));
syncSchedule3(context);
return { ok: true, message: "NPC pregnancy updated.", refresh: true };
}
},
sync({ game, controls }) {
const key = controls.value("npc");
const timer = game.get(`storedNPCs.${key}.pregnancy.timer`);
const timerEnd = game.get(`storedNPCs.${key}.pregnancy.timerEnd`);
controls.setValue("days", Number.isFinite(timerEnd - timer) ? (timerEnd - timer) / 3 : "");
controls.setValue("locked", lockedDays3.has(key));
},
onEnable(context) {
syncSchedule3(context);
return () => context.services.scheduler?.unregister(LOCK_JOB_ID3, { cadence: "frame" });
}
});
// src/cheat/definitions/world/vrel-coins-usage.cheat.js
var PATH3 = "featsBoosts.pointsUsed";
var vrelCoinsUsageCheat = createCheat({
id: "world.vrel-coins-usage",
location: { section: "misc", group: "mod-integration", order: 140 },
meta: {
label: "Reset Vrel Coins Usage",
controls: [
{ key: "current", type: "text" },
{ key: "reset", type: "button", label: "Reset", action: "reset" }
]
},
requiredPaths: [PATH3],
isApplicable({ game }) {
return Number.isFinite(game.get(PATH3));
},
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
reset({ game }) {
game.set(PATH3, 0);
return { ok: true, message: "Vrel coins usage reset.", refresh: true };
}
},
sync({ game, controls }) {
controls.text("current", game.get(PATH3));
}
});
// src/cheat/catalog/generated.js
var generatedCheats = Object.freeze([
runDiagnosticsCheat,
ballsCheat,
bodySizeCheat,
bodyTypeCheat,
characteristicsCheat,
crimeCheat,
cumCheat,
enemyStatsCheat,
examCheat,
fameCheat,
hentaiSkillCheat,
infiniteArousalCheat,
lactationCheat,
milkCheat,
moneyCheat,
parasitesCheat,
schoolReputationCheat,
playerStatsCheat,
talentCheat,
unlimitedSprayCheat,
virginityCheat,
arousalCheat,
autoChildInteractionCheat,
edenGardenCheat,
edenMushroomsCheat,
edenSpringCheat,
edenTimerCheat,
enemyStateCheat,
everyoneHornyCheat,
farmSafetyCheat,
gameCheatsCheat,
hygieneCheat,
infiniteNpcPregnancyCheat,
intenseCumCheat,
invincibleAngelCheat,
maintainPurityCheat,
maintainVirginityCheat,
maximumNpcPregnancyRateCheat,
maximumStrayTasksCheat,
multipleNpcPregnanciesCheat,
playerStateCheat,
pregnancyDetectionCheat,
randomEncountersCheat,
templeVowCheat,
unlimitedCumCheat,
farmAnimalAffinityCheat,
farmAssaultTimeCheat,
farmBuildTimeCheat,
maxHarmonyCheat,
maximumChurchTasksCheat,
mcAbortionCheat,
mcChildManagerCheat,
mcPregnancyCheat,
mcTentacleCheat,
namedNpcAbortionCheat,
namedNpcPregnancyCheat,
npcTraitEditorCheat,
produceSalesReportCheat,
storedNpcAbortionCheat,
storedNpcPregnancyCheat,
vrelCoinsUsageCheat
]);
// src/cheat/catalog.js
var SECTION_ORDER = ["quick", "stats", "misc"];
function createCheatCatalog(descriptors, { configPaths = CHEAT_CONFIG_SCHEMA.map(({ path: path7 }) => path7) } = {}) {
if (!Array.isArray(descriptors)) throw new TypeError("Cheat catalog input must be an array.");
const paths = new Set(configPaths), byId = /* @__PURE__ */ new Map(), placements = /* @__PURE__ */ new Map();
for (const descriptor of descriptors) {
validateCheatDefinition(descriptor);
if (byId.has(descriptor.id))
throw new Error(`Duplicate cheat descriptor id "${descriptor.id}".`);
const placement = `${descriptor.location.section}:${descriptor.location.group ?? ""}:${descriptor.location.order}`;
if (placements.has(placement))
throw new Error(
`Duplicate cheat placement "${placement}" for "${placements.get(placement)}" and "${descriptor.id}".`
);
for (const path7 of descriptor.config ?? [])
if (!paths.has(path7))
throw new Error(`Cheat "${descriptor.id}" references unknown config path "${path7}".`);
placements.set(placement, descriptor.id);
byId.set(descriptor.id, descriptor);
}
const ordered = [...byId.values()].sort(
(a, b) => SECTION_ORDER.indexOf(a.location.section) - SECTION_ORDER.indexOf(b.location.section) || a.location.order - b.location.order || (a.location.group ?? "").localeCompare(b.location.group ?? "") || a.id.localeCompare(b.id)
);
return Object.freeze({
listCheats: () => [...ordered],
getCheat: (id) => byId.get(id) ?? null,
listCheatsForSection: (section) => ordered.filter((cheat2) => cheat2.location.section === section)
});
}
// src/cheat/index.js
var cheatCatalog = createCheatCatalog(generatedCheats);
// src/ui/shell/renderer.js
var mountedShells = /* @__PURE__ */ new WeakMap();
function renderControl(control, document2, dispatchAction, cleanup) {
let element;
if (control.type === "heading") {
element = document2.createElement("span");
element.className = "gold";
} else if (control.type === "help") {
element = document2.createElement("span");
element.className = "cp-shell-help";
} else if (control.type === "link") {
element = document2.createElement("a");
element.className = "modal-link";
element.href = control.href;
element.target = "_blank";
element.rel = "noopener noreferrer";
} else if (control.type === "action") {
element = document2.createElement("button");
element.type = "button";
element.className = "modal-button";
const handler = () => dispatchAction?.(control.action);
element.addEventListener("click", handler);
cleanup.push(() => element.removeEventListener("click", handler));
} else {
element = document2.createElement("span");
element.className = "modal-text";
}
element.textContent = control.text ?? "";
if (control.key) element.dataset.shellControl = control.key;
if (control.action) element.dataset.shellAction = control.action;
return element;
}
function teardownSectionShell(container) {
const state = mountedShells.get(container);
if (!state) return false;
state.cleanup.forEach((fn) => fn());
state.root.remove();
mountedShells.delete(container);
return true;
}
function renderSectionShell({ section, rows, container, document: document2, dispatchAction }) {
if (!container) throw new TypeError("Shell renderer requires a section container.");
teardownSectionShell(container);
const cleanup = [];
const root = document2.createElement("div");
root.className = "cp-section-shell";
root.dataset.shellSection = section;
for (const definition of rows ?? []) {
const row = document2.createElement("div");
row.className = `modal-content-padding cp-layout-${definition.role}`;
row.dataset.shellKey = `${section}.${definition.key}`;
const groups = definition.groups ?? (definition.group ? [definition.group] : []);
if (groups.length) row.dataset.shellGroups = groups.join(" ");
for (const control of definition.controls ?? []) {
if (!control.text) continue;
row.appendChild(renderControl(control, document2, dispatchAction, cleanup));
}
root.appendChild(row);
}
container.appendChild(root);
mountedShells.set(container, { root, cleanup });
return Object.freeze({ root, dispose: () => teardownSectionShell(container) });
}
// src/cheat/runtime/catalog-plan.js
var CHEAT_SECTIONS = Object.freeze(["quick", "stats", "misc"]);
function compileCatalogPlan(catalog, { sections = CHEAT_SECTIONS } = {}) {
if (!catalog?.listCheats) throw new TypeError("Cheat builder requires a catalog.");
const descriptors = Object.freeze(catalog.listCheats());
const bySection = new Map(
sections.map((section) => [
section,
Object.freeze(
descriptors.filter((descriptor) => descriptor.location.section === section)
)
])
);
return Object.freeze({
descriptors,
sections: Object.freeze([...sections]),
listSection: (section) => bySection.get(section) ?? Object.freeze([])
});
}
// src/cheat/runtime/builder-contract.js
var BUILDER_LIFECYCLE_METHODS = Object.freeze([
"compile",
"configureSections",
"mountSection",
"sectionOpened",
"teardown",
"health"
]);
function createBuilderLifecycleHandle(implementation) {
if (!implementation || typeof implementation !== "object") {
throw new TypeError("Builder lifecycle implementation must be an object.");
}
for (const method of BUILDER_LIFECYCLE_METHODS) {
if (typeof implementation[method] !== "function") {
throw new TypeError(`Builder lifecycle requires ${method}().`);
}
}
return Object.freeze({ ...implementation });
}
// src/ui/cheat-controls/layout-primitives.js
var LAYOUT_CLASSES = Object.freeze({
row: "cp-layout-row",
cheat: "cp-layout-cheat-row",
group: "cp-layout-group",
heading: "cp-layout-heading",
help: "cp-layout-help",
spacer: "cp-layout-spacer",
footer: "cp-layout-footer"
});
// src/cheat/runtime/game-context.js
var CheatRuntimeUnavailableError = class extends Error {
constructor(message = "Active game runtime is not ready.") {
super(message);
this.name = "CheatRuntimeUnavailableError";
this.code = "CHEAT_RUNTIME_UNAVAILABLE";
}
};
var CheatGamePathError = class extends Error {
constructor(path7) {
super(`Game path "${path7}" cannot be written because its parent is missing.`);
this.name = "CheatGamePathError";
this.code = "CHEAT_GAME_PATH_MISSING";
this.path = path7;
}
};
var partsOf = (path7) => Array.isArray(path7) ? path7.map(String).filter(Boolean) : String(path7 ?? "").split(".").map((part) => part.trim()).filter(Boolean);
function readPath(root, path7) {
let value = root;
for (const part of partsOf(path7)) {
if (value == null || !Object.hasOwn(value, part)) return void 0;
value = value[part];
}
return value;
}
function createGameContext(adapter) {
if (!adapter || typeof adapter !== "object")
throw new TypeError("Game context requires an adapter.");
function variables() {
if (typeof adapter.isReady === "function" && !adapter.isReady()) {
throw new CheatRuntimeUnavailableError();
}
const value = adapter.variables?.() ?? adapter.getVariables?.();
if (!value || typeof value !== "object") throw new CheatRuntimeUnavailableError();
return value;
}
return Object.freeze({
variables,
get(path7) {
return readPath(variables(), path7);
},
set(path7, value) {
const parts = partsOf(path7);
if (!parts.length) throw new CheatGamePathError(path7);
let parent = variables();
for (const part of parts.slice(0, -1)) {
if (!parent?.[part] || typeof parent[part] !== "object") throw new CheatGamePathError(path7);
parent = parent[part];
}
parent[parts.at(-1)] = value;
return value;
},
has(path7) {
return readPath(variables(), path7) !== void 0;
},
setup(path7) {
const setup = adapter.setup?.() ?? adapter.getSetup?.();
if (!setup || typeof setup !== "object")
throw new CheatRuntimeUnavailableError("Game setup is not ready.");
return path7 == null || path7 === "" ? setup : readPath(setup, path7);
},
passage() {
return adapter.passage?.() ?? adapter.getCurrentPassage?.() ?? null;
}
});
}
// src/cheat/runtime/context.js
function createNarrowConfig(descriptor, provider) {
const declared = new Set(descriptor.config ?? []);
const requirePath = (path7) => {
if (!declared.has(path7))
throw new Error(`Cheat "${descriptor.id}" did not declare config path "${path7}".`);
};
return Object.freeze({
get(path7) {
requirePath(path7);
return provider.get(path7);
},
set(path7, value) {
requirePath(path7);
return provider.set(path7, value);
},
has(path7) {
requirePath(path7);
return provider.has(path7);
},
scope(path7) {
requirePath(path7);
return provider.scope(path7);
}
});
}
function createCheatCallbackContext({
descriptor,
adapter,
config,
controls,
signal,
reason,
event = null,
feedback,
services = {}
}) {
if (!descriptor?.id) throw new TypeError("Callback context requires a descriptor.");
if (!signal) throw new TypeError("Callback context requires an operation signal.");
const allowedServices = Object.freeze({
scheduler: services.scheduler,
logger: services.logger,
diagnostics: services.diagnostics
});
return Object.freeze({
cheat: descriptor,
game: createGameContext(adapter),
config: createNarrowConfig(descriptor, config),
controls,
event,
signal,
reason,
feedback,
services: allowedServices
});
}
// src/cheat/runtime/control-scope.js
function createControlScope({ descriptor, root }) {
if (!descriptor?.id) throw new TypeError("Control scope requires a descriptor.");
if (!root?.querySelectorAll) throw new TypeError("Control scope requires a mounted root.");
const definitions = new Map(
(descriptor.meta?.controls ?? []).map((control) => [control.key, control])
);
const elements = /* @__PURE__ */ new Map();
for (const element2 of root.querySelectorAll("[data-cheat-control]")) {
const key = element2.dataset.cheatControl;
if (definitions.has(key)) elements.set(key, element2);
}
function element(key) {
const found = elements.get(key);
if (!found) throw new Error(`Cheat "${descriptor.id}" has no mounted control "${key}".`);
return found;
}
function syncPresentation(target) {
if (target.dataset.toggleButton === "true") {
const active = target.getAttribute("aria-pressed") === "true";
target.classList.toggle("cp-toggle-active", active);
return;
}
if (target.type !== "checkbox") return;
const wrapper = target.closest(".modal-toggle");
wrapper?.classList.toggle("cp-toggle-active", Boolean(target.checked));
}
const value = (key) => {
const target = element(key);
return target.dataset.toggleButton === "true" ? target.getAttribute("aria-pressed") === "true" : target.type === "checkbox" ? Boolean(target.checked) : "value" in target ? target.value : target.textContent;
};
return Object.freeze({
element,
value,
number: (key) => Number(value(key)),
checked: (key) => {
const target = element(key);
return target.dataset.toggleButton === "true" ? target.getAttribute("aria-pressed") === "true" : Boolean(target.checked);
},
setValue(key, next) {
const target = element(key);
if (target.dataset.toggleButton === "true")
target.setAttribute("aria-pressed", String(Boolean(next)));
else if (target.type === "checkbox") target.checked = Boolean(next);
else if ("value" in target) target.value = next == null ? "" : String(next);
else target.textContent = next == null ? "" : String(next);
syncPresentation(target);
},
text(key, next) {
element(key).textContent = next == null ? "" : String(next);
},
options(key, options6 = []) {
const target = element(key);
if (target.tagName !== "SELECT") throw new Error(`Cheat control "${key}" is not a select.`);
const selected = target.value;
target.replaceChildren(
...options6.map((option) => {
const node = target.ownerDocument.createElement("option");
const normalized = option && typeof option === "object" ? option : { value: option, label: option };
node.value = String(normalized.value ?? "");
node.textContent = String(normalized.label ?? normalized.value ?? "");
return node;
})
);
if ([...target.options].some(({ value: value2 }) => value2 === selected)) target.value = selected;
return Object.freeze({
previousValue: selected,
value: target.value,
selectionChanged: Boolean(selected) && target.value !== selected
});
},
setEnabled(key, enabled, reason = "") {
const target = element(key);
target.disabled = !enabled;
const wrapper = target.closest(".modal-toggle");
if (wrapper) wrapper.setAttribute("aria-disabled", String(!enabled));
if (reason) target.dataset.disabledReason = reason;
else delete target.dataset.disabledReason;
}
});
}
// src/cheat/runtime/action-outcome.js
function normalizeCheatActionOutcome(value) {
if (value === false) return Object.freeze({ ok: false, kind: "validation" });
if (value === true || value == null) return Object.freeze({ ok: true, kind: "success" });
if (typeof value === "object") {
const ok = value.ok !== false;
return Object.freeze({ kind: ok ? "success" : "validation", ...value, ok });
}
return Object.freeze({ ok: true, kind: "success", value });
}
function normalizeCheatActionError(error) {
const blocked = error instanceof CheatRuntimeUnavailableError;
return Object.freeze({
ok: false,
kind: blocked ? "blocked" : "error",
variant: blocked ? "warning" : "error",
message: error?.message ?? String(error),
error
});
}
// src/cheat/runtime/sync-telemetry.js
function developmentBuild() {
try {
return Boolean(false);
} catch {
return false;
}
}
function createSyncTelemetry({ enabled = true } = {}) {
const sections = /* @__PURE__ */ new Map();
const entry2 = (section) => {
if (!sections.has(section)) {
sections.set(section, {
calls: 0,
durationMs: 0,
skippedHidden: 0,
suppressedWrites: 0,
coordinatorTicks: 0,
coordinatorDurationMs: 0
});
}
return sections.get(section);
};
return Object.freeze({
record(section, { durationMs = 0, suppressedWrites = 0 } = {}) {
if (!enabled) return;
const metrics = entry2(section);
metrics.calls += 1;
metrics.durationMs += durationMs;
metrics.suppressedWrites += suppressedWrites;
},
hidden(section) {
if (enabled) entry2(section).skippedHidden += 1;
},
coordinatorTick(section, { durationMs = 0 } = {}) {
if (!enabled) return;
const metrics = entry2(section);
metrics.coordinatorTicks += 1;
metrics.coordinatorDurationMs += durationMs;
},
snapshot() {
return Object.freeze(
Object.fromEntries([...sections].map(([section, metrics]) => [section, { ...metrics }]))
);
},
reset() {
sections.clear();
}
});
}
var syncTelemetry = createSyncTelemetry({ enabled: developmentBuild() });
// src/cheat/runtime/renderer.js
var EVENT_BY_TYPE = Object.freeze({
button: "click",
toggle: "change",
select: "change",
range: "input",
input: "input"
});
function createControl(document2, definition) {
const confirmationToggle = definition.type === "toggle" && definition.intent === "confirmation";
const tag = definition.type === "button" || definition.type === "toggle" && !confirmationToggle ? "button" : definition.type === "select" ? "select" : definition.type === "text" ? "span" : "input";
const element = document2.createElement(tag);
element.dataset.cheatControl = definition.key;
element.classList.add("cp-cheat-control", `cp-cheat-control--${definition.type}`);
if (definition.type !== "text")
element.setAttribute("aria-label", definition.label ?? definition.key);
if (definition.tooltip) element.title = definition.tooltip;
if (definition.type === "button" || definition.type === "toggle" && !confirmationToggle) {
element.type = "button";
element.textContent = definition.label ?? "";
element.classList.add("modal-button");
}
if (definition.type === "toggle" && !confirmationToggle) {
element.dataset.toggleButton = "true";
element.setAttribute("aria-pressed", "false");
Object.defineProperty(element, "checked", {
configurable: true,
get: () => element.getAttribute("aria-pressed") === "true",
set: (next) => {
element.setAttribute("aria-pressed", String(Boolean(next)));
}
});
}
if (confirmationToggle) {
element.type = "checkbox";
const wrapper = document2.createElement("label");
wrapper.className = "modal-toggle cp-cheat-toggle";
const label = document2.createElement("span");
label.className = "toggle-label";
label.textContent = definition.label ?? definition.key;
wrapper.append(element, label);
return wrapper;
}
if (definition.type === "range") {
element.type = "range";
element.classList.add("cp-cheat-range");
}
if (definition.type === "input") {
element.type = "text";
element.classList.add("modal-content-width");
element.autocomplete = "off";
}
if (definition.type === "select") element.classList.add("cp-cheat-select");
if (definition.type === "text") {
element.textContent = definition.label ?? "";
element.classList.add("modal-text");
if (definition.intent === "status") element.classList.add("cp-status-chip");
}
return element;
}
function createTooltip(document2, message, className = "") {
const tooltip = document2.createElement("span");
tooltip.className = `tooltip-small linkBlue ${className}`.trim();
tooltip.tabIndex = 0;
tooltip.setAttribute("aria-label", message);
tooltip.textContent = "(?)";
const content = document2.createElement("span");
content.textContent = message;
tooltip.appendChild(content);
return tooltip;
}
function createControlUnit(document2, definition) {
const unit = document2.createElement("span");
unit.className = "cp-cheat-control-unit";
if (definition.intent === "confirmation") unit.classList.add("cp-confirmation-control");
if (definition.intent === "status") unit.classList.add("cp-status-control");
unit.appendChild(createControl(document2, definition));
if (definition.tooltip)
unit.appendChild(createTooltip(document2, definition.tooltip, "cp-cheat-tooltip"));
return unit;
}
function setControlNotice(control, message = "", kind = "info") {
const unit = control.closest(".cp-cheat-control-unit");
if (!unit) return;
let notice = unit.querySelector(".cp-control-notice");
if (!message) {
notice?.remove();
return;
}
if (!notice) {
notice = control.ownerDocument.createElement("small");
notice.className = "cp-control-notice";
notice.setAttribute("aria-live", "polite");
unit.appendChild(notice);
}
notice.dataset.noticeKind = kind;
notice.textContent = message;
}
function coerceBindingValue(value, type = "string") {
if (type === "number") return Number(value);
if (type === "integer") return Number.parseInt(value, 10);
if (type === "boolean") return Boolean(value);
return String(value ?? "");
}
async function mountCheatDescriptor({
descriptor,
document: document2,
parent = document2.body,
adapter,
config,
feedback = {},
services = {},
confirm = null
}) {
if (!descriptor?.id) throw new TypeError("Descriptor renderer requires a cheat descriptor.");
const root = document2.createElement("section");
root.dataset.cheatId = descriptor.id;
root.className = `modal-content-padding cp-cheat-descriptor ${LAYOUT_CLASSES.row} ${LAYOUT_CLASSES.cheat}`;
const label = document2.createElement("span");
label.className = "modal-text cp-cheat-label";
label.textContent = descriptor.meta.label;
const availabilityTooltip = createTooltip(document2, "", "cp-availability-tooltip");
availabilityTooltip.hidden = true;
availabilityTooltip.style.display = "none";
label.appendChild(availabilityTooltip);
const controlsRegion = document2.createElement("span");
controlsRegion.className = "cp-cheat-controls";
const availabilityStatus = document2.createElement("small");
availabilityStatus.className = "cp-cheat-status";
availabilityStatus.setAttribute("role", "status");
availabilityStatus.hidden = true;
root.append(label, controlsRegion, availabilityStatus);
for (const definition of descriptor.meta.controls)
controlsRegion.appendChild(createControlUnit(document2, definition));
parent.appendChild(root);
const controls = createControlScope({ descriptor, root });
const controller = new AbortController();
const listeners = [];
const cleanups = [];
const pending = /* @__PURE__ */ new Map();
const editedControls = /* @__PURE__ */ new Set();
let queuedRefresh = null;
let disposed = false;
let applicable = true;
let unavailableReason = "";
let lifecycleActive = false;
let enabledCleanup = null;
let toggleCleanup = null;
let actionDepth = 0;
let deferredRefresh = null;
let warnedUndeclaredSyncWrite = false;
const canWrite = () => !disposed && !controller.signal.aborted;
for (const definition of descriptor.meta.controls) {
if (definition.type === "select" && Array.isArray(definition.options))
controls.options(definition.key, definition.options);
if (definition.value !== void 0) controls.setValue(definition.key, definition.value);
}
const context = (reason, event = null, callbackControls = controls) => createCheatCallbackContext({
descriptor,
adapter,
config,
controls: callbackControls,
signal: controller.signal,
reason,
event,
feedback,
services
});
const notify = (outcome) => {
if (!outcome.message) return;
const variant = outcome.variant ?? (outcome.ok ? "success" : outcome.kind === "blocked" ? "warning" : "error");
feedback[variant]?.(outcome.message);
};
const reportSyncFailure = (reason, error) => {
services.logger?.error?.("Cheat sync failed.", {
cheatId: descriptor.id,
trigger: reason,
errorType: error instanceof Error ? error.name : "UnknownError"
});
};
const isVisible = () => !root.hidden && root.getAttribute("aria-hidden") !== "true" && root.style.display !== "none";
const isEditable = (key) => {
const target = controls.element(key);
return target.tagName === "INPUT" || target.tagName === "SELECT" || target.tagName === "TEXTAREA";
};
const isEditProtected = (key) => isEditable(key) && (editedControls.has(key) || document2.activeElement === controls.element(key));
const warnUndeclaredSyncWrite = (key) => {
if (warnedUndeclaredSyncWrite || descriptor.refresh?.length || !isEditable(key)) return;
warnedUndeclaredSyncWrite = true;
services.logger?.warn?.("Cheat sync writes an editable control without a refresh policy.", {
cheatId: descriptor.id,
controlKey: key
});
};
const assessAvailability = (reason) => {
try {
const callbackContext = context(reason);
const missingPath = (descriptor.requiredPaths ?? []).find(
(path7) => !callbackContext.game.has(path7)
);
if (missingPath)
return {
applicable: false,
reason: `Required game path "${missingPath}" is unavailable.`
};
if (descriptor.isApplicable && !descriptor.isApplicable(callbackContext))
return {
applicable: false,
reason: "Cheat is not applicable in the current game state."
};
return { applicable: true, reason: "" };
} catch (error) {
return { applicable: false, reason: error?.message ?? "Cheat availability check failed." };
}
};
const renderAvailability = (next) => {
applicable = next.applicable;
unavailableReason = next.reason;
root.classList.toggle("cp-cheat-unavailable", !applicable);
availabilityStatus.hidden = true;
availabilityStatus.textContent = applicable ? "" : unavailableReason;
availabilityTooltip.hidden = applicable;
availabilityTooltip.style.display = applicable ? "none" : "";
availabilityTooltip.setAttribute("aria-label", applicable ? "" : unavailableReason);
availabilityTooltip.querySelector("span").textContent = applicable ? "" : unavailableReason;
for (const definition of descriptor.meta.controls)
controls.setEnabled(definition.key, applicable);
};
async function activateLifecycle(reason) {
if (lifecycleActive || !applicable) return;
lifecycleActive = true;
enabledCleanup = await descriptor.onEnable?.(context(reason));
toggleCleanup = await services.toggle?.attach?.(descriptor, context(reason));
}
async function deactivateLifecycle(reason) {
if (!lifecycleActive) return;
lifecycleActive = false;
await descriptor.onDisable?.(context(reason));
if (typeof toggleCleanup === "function") await toggleCleanup();
if (typeof enabledCleanup === "function") await enabledCleanup();
toggleCleanup = null;
enabledCleanup = null;
}
async function refreshAvailability(reason) {
const next = assessAvailability(reason);
const changed = next.applicable !== applicable || next.reason !== unavailableReason;
if (!changed) return applicable;
if (!next.applicable) await deactivateLifecycle(reason);
renderAvailability(next);
if (next.applicable) await activateLifecycle(reason);
return applicable;
}
const sync = async (reason = "manual", event = null) => {
if (disposed) return false;
const telemetry = services.syncTelemetry ?? syncTelemetry;
const section = descriptor.location.section;
if (reason !== "manual" && reason !== "mount" && !isVisible()) {
telemetry.hidden(section);
return false;
}
const startedAt = services.clock?.now?.() ?? globalThis.performance?.now?.() ?? Date.now();
let suppressedWrites = 0;
await refreshAvailability(reason);
if (!applicable) return false;
const guardedControls = Object.freeze({
...controls,
setValue(key, next) {
if (!canWrite()) return false;
if (isEditProtected(key)) {
suppressedWrites += 1;
return false;
}
warnUndeclaredSyncWrite(key);
controls.setValue(key, next);
return true;
},
text(key, next) {
if (!canWrite()) return false;
if (isEditProtected(key)) {
suppressedWrites += 1;
return false;
}
warnUndeclaredSyncWrite(key);
controls.text(key, next);
return true;
},
options(key, options6) {
if (!canWrite()) {
return Object.freeze({
previousValue: controls.value(key),
value: controls.value(key),
selectionChanged: false,
suppressed: true
});
}
if (isEditProtected(key)) {
suppressedWrites += 1;
return Object.freeze({
previousValue: controls.value(key),
value: controls.value(key),
selectionChanged: false,
suppressed: true
});
}
warnUndeclaredSyncWrite(key);
return controls.options(key, options6);
}
});
const callbackContext = context(reason, event, guardedControls);
const refreshOptionLists = async () => {
for (const definition of descriptor.meta.controls) {
if (definition.type !== "select" || typeof definition.options !== "function") continue;
let options6;
let optionError = false;
try {
options6 = await definition.options(callbackContext);
} catch (error) {
options6 = [];
optionError = true;
reportSyncFailure(reason, error);
}
const actualOptions = Array.isArray(options6) ? options6 : [];
const empty = actualOptions.length === 0;
const result = guardedControls.options(
definition.key,
!empty || !definition.fallbackOptions ? actualOptions : definition.fallbackOptions ?? []
);
if (result.suppressed) continue;
const select = controls.element(definition.key);
select.disabled = empty;
select.dataset.optionState = optionError ? "unavailable" : empty ? "empty" : "ready";
const optionMessage = optionError ? "Options are temporarily unavailable." : empty ? definition.fallbackOptions?.[0]?.label ?? "No options are currently available." : result.selectionChanged ? "The previous selection is no longer available." : "";
setControlNotice(select);
select.title = optionMessage || definition.tooltip || "";
if (optionMessage) select.setAttribute("aria-description", optionMessage);
else select.removeAttribute("aria-description");
}
};
const refreshBoundValues = () => {
if (!canWrite()) return;
for (const definition of descriptor.meta.controls) {
if (!definition.binding) continue;
if (isEditProtected(definition.key) && !definition.binding.syncWhileEditing) {
suppressedWrites += 1;
continue;
}
controls.setValue(definition.key, callbackContext.game.get(definition.binding.path));
}
};
try {
await refreshOptionLists();
if (!canWrite()) return false;
refreshBoundValues();
await descriptor.sync?.(callbackContext);
telemetry.record(section, {
durationMs: (services.clock?.now?.() ?? globalThis.performance?.now?.() ?? Date.now()) - startedAt,
suppressedWrites
});
return true;
} catch (error) {
telemetry.record(section, {
durationMs: (services.clock?.now?.() ?? globalThis.performance?.now?.() ?? Date.now()) - startedAt,
suppressedWrites
});
reportSyncFailure(reason, error);
return false;
}
};
const requestRefresh = (reason = "manual", event = null) => {
if (actionDepth > 0) {
deferredRefresh = { reason, event };
return Promise.resolve(false);
}
if (queuedRefresh) return queuedRefresh;
queuedRefresh = Promise.resolve().then(() => sync(reason, event)).finally(() => {
queuedRefresh = null;
});
return queuedRefresh;
};
async function runAction(name, { event = null, controlKey = null } = {}) {
if (disposed)
return normalizeCheatActionError(new Error(`Cheat "${descriptor.id}" is disposed.`));
if (!applicable) {
const outcome = Object.freeze({
ok: false,
kind: "blocked",
variant: "warning",
message: unavailableReason
});
if (!disposed) notify(outcome);
return outcome;
}
const pendingKey = controlKey ?? name;
if (pending.has(pendingKey)) return pending.get(pendingKey);
const action = descriptor.actions?.[name];
if (typeof action !== "function")
throw new Error(`Cheat "${descriptor.id}" has no local action "${name}".`);
if (descriptor.meta.confirmation) {
const accepted = typeof confirm === "function" && await confirm(descriptor.meta.confirmation, descriptor);
if (!accepted) {
const outcome = Object.freeze({
ok: false,
kind: "blocked",
variant: "warning",
message: "Action cancelled."
});
notify(outcome);
return outcome;
}
}
const element = controlKey ? controls.element(controlKey) : null;
const lockDuringAction = element?.tagName === "BUTTON";
if (lockDuringAction) element.disabled = true;
const operation = (async () => {
let outcome;
actionDepth += 1;
try {
outcome = normalizeCheatActionOutcome(await action(context("action", event)));
} catch (error) {
outcome = normalizeCheatActionError(error);
} finally {
actionDepth -= 1;
}
if (!disposed) notify(outcome);
const requestedAfterAction = outcome.ok && (outcome.refresh || descriptor.refresh?.includes("after-action"));
const pendingRefresh = deferredRefresh;
deferredRefresh = null;
if (requestedAfterAction || pendingRefresh)
await requestRefresh(
requestedAfterAction ? "after-action" : pendingRefresh.reason,
requestedAfterAction ? event : pendingRefresh.event
);
return outcome;
})();
pending.set(pendingKey, operation);
try {
return await operation;
} finally {
pending.delete(pendingKey);
if (lockDuringAction && !disposed) element.disabled = false;
}
}
async function runToggle(controlKey, event) {
const enabled = controls.checked(controlKey);
controls.setValue(controlKey, enabled);
if (typeof services.toggle?.setEnabled !== "function") {
const outcome = Object.freeze({
ok: false,
kind: "blocked",
variant: "warning",
message: "Toggle runtime is unavailable."
});
notify(outcome);
return outcome;
}
try {
return normalizeCheatActionOutcome(
await services.toggle.setEnabled(descriptor, enabled, context("action", event))
);
} catch (error) {
const outcome = normalizeCheatActionError(error);
notify(outcome);
return outcome;
}
}
for (const definition of descriptor.meta.controls) {
const element = controls.element(definition.key);
if (isEditable(definition.key)) {
const markEdited = () => editedControls.add(definition.key);
const clearEdited = () => editedControls.delete(definition.key);
element.addEventListener("input", markEdited);
element.addEventListener("change", markEdited);
element.addEventListener("blur", clearEdited);
listeners.push(() => element.removeEventListener("input", markEdited));
listeners.push(() => element.removeEventListener("change", markEdited));
listeners.push(() => element.removeEventListener("blur", clearEdited));
}
if (definition.binding) {
if (definition.binding.writeOn) {
const write = () => {
const value = coerceBindingValue(
controls.value(definition.key),
definition.binding.coerce
);
context("action").game.set(definition.binding.path, value);
};
element.addEventListener(definition.binding.writeOn, write);
listeners.push(() => element.removeEventListener(definition.binding.writeOn, write));
}
}
if (definition.type === "toggle" && definition.action === "toggle") {
const listener2 = (event) => {
if (element.dataset.toggleButton === "true")
controls.setValue(definition.key, !controls.checked(definition.key));
void runToggle(definition.key, event);
};
element.addEventListener("click", listener2);
listeners.push(() => element.removeEventListener("click", listener2));
const legacyChangeListener = (event) => void runToggle(definition.key, event);
element.addEventListener("change", legacyChangeListener);
listeners.push(() => element.removeEventListener("change", legacyChangeListener));
continue;
}
if (!definition.action) continue;
if (typeof descriptor.actions?.[definition.action] !== "function")
throw new Error(
`Cheat "${descriptor.id}" control "${definition.key}" references missing local action "${definition.action}".`
);
const eventName = definition.event ?? EVENT_BY_TYPE[definition.type] ?? "click";
const listener = (event) => void runAction(definition.action, { event, controlKey: definition.key });
element.addEventListener(eventName, listener);
listeners.push(() => element.removeEventListener(eventName, listener));
}
renderAvailability(assessAvailability("mount"));
await activateLifecycle("mount");
if (applicable && descriptor.refresh?.includes("mount")) await requestRefresh("mount");
return Object.freeze({
descriptor,
root,
controls,
signal: controller.signal,
get applicable() {
return applicable;
},
runAction,
sync,
requestRefresh,
sectionOpened(event = null) {
if (!descriptor.refresh?.includes("section-open")) return Promise.resolve(false);
return requestRefresh("section-open", event);
},
runtimeTick(event = null) {
if (!descriptor.refresh?.includes("runtime-tick")) return Promise.resolve(false);
return requestRefresh("runtime-tick", event);
},
async waitForIdle() {
await Promise.all([...pending.values()]);
},
async dispose() {
if (disposed) return false;
disposed = true;
controller.abort(new DOMException("descriptor disposed", "AbortError"));
listeners.splice(0).reverse().forEach((cleanup) => cleanup());
root.remove();
await deactivateLifecycle("dispose");
const disposeCleanup = await descriptor.dispose?.(context("dispose"));
if (typeof disposeCleanup === "function") cleanups.push(disposeCleanup);
cleanups.splice(0).reverse().forEach((cleanup) => cleanup());
return true;
}
});
}
// src/cheat/runtime/refresh-coordinator.js
var DEFAULT_INTERVAL_MS = 400;
function createUiRefreshCoordinator({
timerApi,
intervalMs = DEFAULT_INTERVAL_MS,
telemetry = null,
clock = globalThis.performance
} = {}) {
if (!timerApi?.setInterval || !timerApi?.clearInterval)
throw new TypeError("UI refresh coordinator requires a window timer API.");
const sections = /* @__PURE__ */ new Map();
let activeSection = null;
let timer = null;
let running = null;
const stopTimer = () => {
if (timer == null) return;
timerApi.clearInterval(timer);
timer = null;
};
const ensureTimer = () => {
if (timer != null || sections.size === 0) return;
timer = timerApi.setInterval(() => void tick(), intervalMs);
};
async function tick() {
if (running || !activeSection) return running ?? false;
const entry2 = sections.get(activeSection);
if (!entry2 || !entry2.isVisible()) return false;
const startedAt = clock?.now?.() ?? Date.now();
running = Promise.resolve(entry2.refresh()).finally(() => {
telemetry?.coordinatorTick?.(activeSection, {
durationMs: (clock?.now?.() ?? Date.now()) - startedAt
});
running = null;
});
await running;
return true;
}
return Object.freeze({
register(section, { refresh, isVisible }) {
if (!section || typeof refresh !== "function" || typeof isVisible !== "function")
throw new TypeError("Refresh registration requires a section, refresh, and visibility check.");
sections.set(section, { refresh, isVisible });
ensureTimer();
},
unregister(section) {
sections.delete(section);
if (activeSection === section) activeSection = null;
if (sections.size === 0) stopTimer();
},
setActiveSection(section) {
activeSection = sections.has(section) ? section : null;
},
tick,
snapshot() {
return Object.freeze({
activeSection,
registeredSections: Object.freeze([...sections.keys()]),
timerCount: timer == null ? 0 : 1
});
},
dispose() {
stopTimer();
sections.clear();
activeSection = null;
}
});
}
// src/cheat/runtime/descriptor-placement.js
function collectGroupTails(shellRoot) {
const tails = /* @__PURE__ */ new Map();
for (const row of shellRoot.querySelectorAll("[data-shell-groups]")) {
const sharedTail = { node: row };
for (const group of row.dataset.shellGroups.split(/\s+/).filter(Boolean)) {
tails.set(group, sharedTail);
}
}
return tails;
}
function placeDescriptorRoot({ root, descriptor, shellRoot, groupTails, fallbackTail }) {
const tail = groupTails.get(descriptor.location.group);
if (tail) {
tail.node.after(root);
tail.node = root;
return fallbackTail;
}
const footer = shellRoot.querySelector(".cp-layout-footer");
if (fallbackTail) fallbackTail.after(root);
else if (footer) footer.before(root);
else shellRoot.appendChild(root);
return root;
}
// src/cheat/runtime/builder-health.js
function freezeFailure(failure) {
return Object.freeze({ ...failure });
}
function createBuilderHealth({ descriptors, mounted, failures, mountedSections }) {
const instances = [...mounted.values()];
const applicable = instances.filter(({ applicable: applicable2 }) => applicable2).length;
return Object.freeze({
total: descriptors.length,
applicable,
mounted: instances.length,
disabled: instances.length - applicable,
failed: failures.size,
mountedSections: Object.freeze([...mountedSections]),
failures: Object.freeze([...failures.values()].map(freezeFailure))
});
}
function describeBuilderFailure(descriptor, phase, error) {
return Object.freeze({
cheatId: descriptor.id,
phase,
code: `CHEAT_${phase.toUpperCase()}_FAILED`,
errorType: error instanceof Error ? error.name : "UnknownError",
message: error instanceof Error ? error.message : String(error ?? "Unknown error")
});
}
// src/cheat/runtime/section-orchestrator.js
function createSectionOrchestrator({
plan,
document: document2,
adapter,
config,
dispatchShellAction,
feedback,
services,
logger,
mountDescriptor,
renderShell,
teardownShell,
refreshCoordinator
}) {
const mounted = /* @__PURE__ */ new Map();
const failures = /* @__PURE__ */ new Map();
const definitions = /* @__PURE__ */ new Map();
const mountedSections = /* @__PURE__ */ new Set();
const generations = /* @__PURE__ */ new Map();
let disposed = false;
let lifecycleGeneration = 0;
function defineSection(section, container, rows = []) {
if (!plan.sections.includes(section)) throw new Error(`Unknown cheat section "${section}".`);
if (!container) throw new TypeError(`Cheat section "${section}" requires a container.`);
disposed = false;
definitions.set(section, { container, rows });
}
async function disposeSection(section) {
refreshCoordinator.unregister(section);
const ids = new Set(plan.listSection(section).map(({ id }) => id));
for (const [id, instance] of [...mounted]) {
if (!ids.has(id)) continue;
await instance.dispose();
mounted.delete(id);
}
mountedSections.delete(section);
}
async function mountSection(section, container, rows = []) {
if (disposed) throw new DOMException("Cheat builder is disposed.", "AbortError");
const generation = (generations.get(section) ?? 0) + 1;
generations.set(section, generation);
defineSection(section, container, rows);
await disposeSection(section);
teardownShell(container);
const shell = renderShell({
section,
rows,
container,
document: document2,
dispatchAction: dispatchShellAction
});
const groupTails = collectGroupTails(shell.root);
let fallbackTail = null;
for (const descriptor of plan.listSection(section)) {
try {
const instance = await mountDescriptor({
descriptor,
document: document2,
parent: shell.root,
adapter,
config,
feedback,
services
});
if (disposed || generations.get(section) !== generation) {
await instance.dispose();
break;
}
fallbackTail = placeDescriptorRoot({
root: instance.root,
descriptor,
shellRoot: shell.root,
groupTails,
fallbackTail
});
mounted.set(descriptor.id, instance);
failures.delete(descriptor.id);
} catch (error) {
const failure = describeBuilderFailure(descriptor, "mount", error);
failures.set(descriptor.id, failure);
logger?.error?.("Cheat descriptor mount failed.", failure);
}
}
if (disposed || generations.get(section) !== generation) {
return health();
}
mountedSections.add(section);
const tickingIds = plan.listSection(section).filter(({ refresh }) => refresh?.includes("runtime-tick")).map(({ id }) => id);
if (tickingIds.length) {
refreshCoordinator.register(section, {
isVisible: () => container.isConnected && !container.hidden && container.getAttribute("aria-hidden") !== "true" && container.style.display !== "none" && container.classList.contains("active"),
refresh: () => Promise.all(tickingIds.map((id) => mounted.get(id)?.runtimeTick())).then(() => true)
});
}
return health();
}
async function openSection(section) {
if (disposed) return false;
const openingGeneration = lifecycleGeneration;
if (!mountedSections.has(section)) {
const definition = definitions.get(section);
if (!definition) return false;
await mountSection(section, definition.container, definition.rows);
}
if (disposed || lifecycleGeneration !== openingGeneration) return false;
refreshCoordinator.setActiveSection(section);
await Promise.all(
plan.listSection(section).map(({ id }) => mounted.get(id)).filter(Boolean).map((instance) => instance.sectionOpened())
);
return true;
}
async function teardown() {
if (disposed) return false;
disposed = true;
lifecycleGeneration += 1;
for (const section of plan.sections) {
generations.set(section, (generations.get(section) ?? 0) + 1);
}
refreshCoordinator.dispose();
const instances = [...mounted.values()];
mounted.clear();
await Promise.all(instances.map((instance) => instance.dispose()));
for (const { container } of definitions.values()) teardownShell(container);
definitions.clear();
mountedSections.clear();
failures.clear();
return instances.length > 0;
}
const health = () => createBuilderHealth({
descriptors: plan.descriptors,
mounted,
failures,
mountedSections
});
return Object.freeze({
defineSection,
mountSection,
openSection,
disposeSection,
teardown,
health,
getMounted: (id) => mounted.get(id) ?? null
});
}
// src/cheat/runtime/builder.js
function createCheatRuntimeBuilder({
catalog,
adapter,
config,
document: document2,
dispatchShellAction,
feedback = {},
services = {},
logger = console,
mountDescriptor = mountCheatDescriptor,
renderShell = renderSectionShell,
teardownShell = teardownSectionShell,
createRefreshCoordinator = createUiRefreshCoordinator,
timerApi = document2?.defaultView,
clock = globalThis.performance,
scheduler = services.scheduler
}) {
if (!adapter) throw new TypeError("Cheat builder requires the active runtime adapter.");
if (!document2) throw new TypeError("Cheat builder requires a document.");
const plan = compileCatalogPlan(catalog);
const runtimeServices = Object.freeze({ ...services, clock, scheduler });
const refreshCoordinator = createRefreshCoordinator({
timerApi,
clock,
telemetry: services.syncTelemetry ?? syncTelemetry
});
const sections = createSectionOrchestrator({
plan,
document: document2,
adapter,
config,
dispatchShellAction,
feedback,
services: runtimeServices,
logger,
mountDescriptor,
renderShell,
teardownShell,
refreshCoordinator
});
let compiled = false;
function compile() {
if (compiled) return false;
compiled = true;
return true;
}
function defineSection(section, container, shellRows = []) {
if (!compiled) compile();
sections.defineSection(section, container, shellRows);
}
function configureSections(sectionDefinitions) {
for (const [section, definition] of Object.entries(sectionDefinitions ?? {})) {
defineSection(section, definition.container, definition.rows ?? []);
}
}
async function mountSection(section, container, shellRows = []) {
if (!compiled) compile();
return sections.mountSection(section, container, shellRows);
}
return createBuilderLifecycleHandle({
compile,
defineSection,
configureSections,
mountSection,
sectionOpened: sections.openSection,
teardown: sections.teardown,
health: sections.health,
listCompiled: () => [...plan.descriptors],
getMounted: sections.getMounted,
refreshCoordinator
});
}
// src/cheat/runtime/config-provider.js
function createAdapterCheatConfigProvider(adapter) {
const schema = new Map(CHEAT_CONFIG_SCHEMA.map((entry2) => [entry2.path, entry2]));
const config = () => adapter.getVariables?.()?.cheatPlus ?? adapter.variables?.()?.cheatPlus;
const definition = (path7) => {
const found = schema.get(path7);
if (!found) throw new Error(`Unknown CheatPlus config path "${path7}".`);
return found;
};
return Object.freeze({
get(path7) {
definition(path7);
return config()?.[path7];
},
set(path7, value) {
const entry2 = definition(path7);
if (!isCheatConfigValueValid(entry2, value))
throw new TypeError(`Invalid value for CheatPlus config path "${path7}".`);
const target = config();
if (!target) throw new Error("CheatPlus config is unavailable.");
target[path7] = value;
return value;
},
has(path7) {
definition(path7);
return Object.hasOwn(config() ?? {}, path7);
},
scope(path7) {
return definition(path7).scope;
}
});
}
// src/platform/sugarcube/toggle-store.js
function createSugarCubeToggleStore() {
return Object.freeze({
read(id) {
return Boolean(getToggles()?.[id]);
},
has(id) {
return Object.hasOwn(getToggles() ?? {}, id);
},
write(id, enabled) {
if (enabled) activateToggle(id);
else deactivateToggle(id);
return Boolean(enabled);
},
remove(id) {
const existed = Object.hasOwn(getToggles() ?? {}, id);
deactivateToggle(id);
return existed;
},
snapshot() {
return { ...getToggles() ?? {} };
}
});
}
// src/cheat/runtime/scheduler.js
var functionMap = /* @__PURE__ */ new Map();
var dailyMap = /* @__PURE__ */ new Map();
var DEFAULT_COOLDOWN_MS = 100;
var DEFAULT_MAX_FAILURES = 5;
var scheduledRun = false;
var frameExpected = 0;
var frameProgress = 0;
var frameFailures = 0;
var framePending = /* @__PURE__ */ new Set();
var frameLastProgressKey = null;
function resetFrameState() {
frameExpected = 0;
frameProgress = 0;
frameFailures = 0;
framePending = /* @__PURE__ */ new Set();
frameLastProgressKey = null;
}
function getFramePendingSample(limit = 8) {
if (!framePending || framePending.size === 0) return [];
const out = [];
for (const key of framePending) {
out.push(key);
if (out.length >= limit) break;
}
return out;
}
function runEntriesSequentially(entries2, { onProgress = null, onDone = null, daily = false } = {}) {
let index = 0;
function step() {
if (index >= entries2.length) {
if (typeof onDone === "function") onDone();
logger_default(
"toggle:scheduler",
`${daily ? "Daily" : "Regular"} batch complete (${index} entries)`
);
return;
}
const [key, meta] = entries2[index++];
const now = Date.now();
if (!meta) {
if (typeof onProgress === "function") onProgress(key);
return requestAnimationFrame(step);
}
if (!daily && now - (meta.lastRun || 0) < (meta.cooldownMs || DEFAULT_COOLDOWN_MS)) {
logger_default(
"toggle:scheduler",
`Skipping ${key}: cooldown not ready (${now - (meta.lastRun || 0)}ms < ${meta.cooldownMs || DEFAULT_COOLDOWN_MS}ms)`
);
if (typeof onProgress === "function") onProgress(key);
return requestAnimationFrame(step);
}
try {
if (typeof meta.fn === "function") {
logger_default("toggle:scheduler", `Executing ${daily ? "daily" : "regular"} toggle: ${key}`);
meta.fn();
if (!daily) meta.lastRun = Date.now();
meta.failureCount = 0;
}
} catch (e) {
meta.failureCount = (meta.failureCount || 0) + 1;
logger_default(
"toggle:scheduler",
`Error executing ${daily ? "daily" : "regular"} toggle: ${key} (failure #${meta.failureCount})`,
{
data: e,
level: "error"
}
);
if (meta.failureCount >= (meta.maxFailures || DEFAULT_MAX_FAILURES)) {
if (daily) {
dailyMap.delete(key);
logger_default(
"toggle:scheduler",
`Unregistered daily toggle: ${key} after ${meta.failureCount} failures`,
{
level: "warn"
}
);
} else {
functionMap.delete(key);
logger_default(
"toggle:scheduler",
`Unregistered regular toggle: ${key} after ${meta.failureCount} failures`,
{
level: "warn"
}
);
}
if (typeof meta.onFailureThreshold === "function") {
meta.onFailureThreshold({ id: key, failures: meta.failureCount, error: e, daily });
}
}
}
if (typeof onProgress === "function") onProgress(key);
requestAnimationFrame(step);
}
step();
}
var ToggleScheduler = {
register(id, fn, {
daily = false,
cooldownMs = DEFAULT_COOLDOWN_MS,
maxFailures = DEFAULT_MAX_FAILURES,
onFailureThreshold = null
} = {}) {
if (!id) return;
logger_default("toggle:scheduler", `Registering ${daily ? "daily" : "regular"} toggle: ${id}`, {
data: { cooldownMs, maxFailures, fnExists: typeof fn === "function" }
});
const meta = {
fn,
lastRun: 0,
failureCount: 0,
cooldownMs,
maxFailures,
onFailureThreshold
};
if (daily) dailyMap.set(id, meta);
else functionMap.set(id, meta);
},
unregister(id, { daily = false } = {}) {
if (!id) return;
logger_default("toggle:scheduler", `Unregistering ${daily ? "daily" : "regular"} toggle: ${id}`);
if (daily) dailyMap.delete(id);
else functionMap.delete(id);
},
runAll({ onProgress = null } = {}) {
const entries2 = Array.from(functionMap.entries());
logger_default("toggle:scheduler", `runAll: ${entries2.length} regular toggles queued`);
runEntriesSequentially(entries2, { onProgress, daily: false });
},
runDaily() {
const entries2 = Array.from(dailyMap.entries());
logger_default("toggle:scheduler", `runDaily: ${entries2.length} daily toggles queued`);
runEntriesSequentially(entries2, { daily: true });
},
runAllDaily() {
this.runDaily();
},
runFrame({
isLoad = false,
onProgress = null,
onFrameState = null,
onWatchdogRestore = null
} = {}) {
if (isLoad) {
logger_default("toggle:scheduler", "Skipping frame: page is loading");
return false;
}
if (frameExpected > 0 && frameProgress < frameExpected) {
frameFailures += 1;
const pendingSample = getFramePendingSample();
logger_default(
"toggle:scheduler",
`Frame watchdog: progress ${frameProgress}/${frameExpected} (failures: ${frameFailures})` + (frameLastProgressKey ? `; last completed: ${frameLastProgressKey}` : "") + (framePending.size ? `; pending ${framePending.size}: ${pendingSample.join(", ")}${framePending.size > pendingSample.length ? ", ..." : ""}` : ""),
{
level: "warn"
}
);
if (typeof onFrameState === "function") {
onFrameState({ expected: frameExpected, progress: frameProgress, failures: frameFailures });
}
if (frameFailures > DEFAULT_MAX_FAILURES) {
const pendingSample2 = getFramePendingSample();
logger_default(
"toggle:scheduler",
`Watchdog triggered: failures exceeded max (${frameFailures} > ${DEFAULT_MAX_FAILURES})` + (framePending.size ? `; pending ${framePending.size}: ${pendingSample2.join(", ")}${framePending.size > pendingSample2.length ? ", ..." : ""}` : ""),
{
level: "warn"
}
);
this.restore({ onRestore: onWatchdogRestore });
}
return false;
}
const entries2 = Array.from(functionMap.entries());
if (!entries2.length) {
resetFrameState();
if (typeof onFrameState === "function") {
onFrameState({ expected: 0, progress: 0, failures: 0 });
}
return false;
}
frameExpected = entries2.length;
frameProgress = 0;
frameFailures = 0;
framePending = new Set(entries2.map(([key]) => key));
frameLastProgressKey = null;
logger_default("toggle:scheduler", `runFrame: Starting frame with ${frameExpected} toggles`);
if (typeof onFrameState === "function") {
onFrameState({ expected: frameExpected, progress: frameProgress, failures: frameFailures });
}
this.scheduleRunAll({
onProgress: (key) => {
frameProgress += 1;
frameLastProgressKey = key;
framePending.delete(key);
if (typeof onProgress === "function") onProgress(key);
}
});
return true;
},
// schedule a coalesced run; multiple calls within a frame result in a single execution
scheduleRunAll({ onProgress = null } = {}) {
if (scheduledRun) {
logger_default("toggle:scheduler", "scheduleRunAll: Already scheduled, skipping coalesce");
return;
}
scheduledRun = true;
requestAnimationFrame(() => {
try {
this.runAll({ onProgress });
} finally {
scheduledRun = false;
}
});
},
getBundles() {
return {
functionbundle: Object.fromEntries(
Array.from(functionMap.entries()).map(([k, meta]) => [k, meta.fn])
),
dailyfunctionbundle: Object.fromEntries(
Array.from(dailyMap.entries()).map(([k, meta]) => [k, meta.fn])
)
};
},
clearAll() {
logger_default(
"toggle:scheduler",
`Clearing all toggles: ${functionMap.size} regular + ${dailyMap.size} daily`
);
functionMap.clear();
dailyMap.clear();
},
reset() {
logger_default("toggle:scheduler", "Resetting scheduler state");
this.clearAll();
resetFrameState();
},
restore({ onRestore = null } = {}) {
logger_default("toggle:scheduler", "Restoring scheduler (full reset)", { level: "warn" });
this.reset();
if (typeof onRestore === "function") onRestore();
},
getFunction(id, { daily = false } = {}) {
const map = daily ? dailyMap : functionMap;
const meta = map.get(id);
return meta?.fn;
},
has(id, { daily = false } = {}) {
return (daily ? dailyMap : functionMap).has(id);
},
list({ daily = null } = {}) {
if (daily === true) return [...dailyMap.keys()];
if (daily === false) return [...functionMap.keys()];
return [...functionMap.keys(), ...dailyMap.keys()];
}
};
// src/cheat/runtime/toggle-runtime.js
function toggleControlKey(descriptor) {
return descriptor.meta.controls.find(
({ type, action }) => type === "toggle" || action === "toggle"
)?.key;
}
function effectContext(base, reason) {
return Object.freeze({ ...base, event: null, reason });
}
function createProductionSchedulerAdapter(scheduler = ToggleScheduler) {
return Object.freeze({
register(id, effect, options6) {
scheduler.register(id, effect, {
daily: options6.cadence === "daily",
cooldownMs: options6.cooldownMs,
maxFailures: options6.maxFailures,
onFailureThreshold: options6.onFailureThreshold
});
},
unregister(id, options6 = {}) {
scheduler.unregister(id, { daily: options6.cadence === "daily" });
},
has(id, options6 = {}) {
return scheduler.has(id, { daily: options6.cadence === "daily" });
},
list() {
return scheduler.list();
},
runFrame(options6 = {}) {
return scheduler.runFrame(options6);
},
runDaily() {
return scheduler.runDaily();
},
reset() {
return scheduler.reset();
}
});
}
function createCheatToggleRuntime({ scheduler, store: store2, logger = console } = {}) {
if (!scheduler?.register || !scheduler?.unregister || !scheduler?.has)
throw new TypeError("Cheat toggle runtime requires a scheduler adapter.");
if (!store2?.read || !store2?.write || !store2?.remove)
throw new TypeError("Cheat toggle runtime requires a toggle store.");
const attached = /* @__PURE__ */ new Map();
function render(entry2, enabled) {
const key = toggleControlKey(entry2.descriptor);
if (key) entry2.context.controls.setValue(key, enabled);
}
async function execute(entry2, reason) {
return entry2.descriptor.effect(effectContext(entry2.context, reason));
}
function quarantine(entry2, details) {
entry2.enabled = false;
render(entry2, false);
store2.remove(entry2.descriptor.id);
logger?.error?.("Cheat toggle quarantined.", {
cheatId: entry2.descriptor.id,
failures: details.failures
});
}
async function setEntryEnabled(entry2, enabled, { restore: restore2 = false } = {}) {
const desired = Boolean(enabled);
const registered = scheduler.has(entry2.descriptor.id, entry2.descriptor.toggle);
if (desired === entry2.enabled && (!desired || registered)) return desired;
entry2.enabled = desired;
render(entry2, desired);
if (!desired) {
scheduler.unregister(entry2.descriptor.id, entry2.descriptor.toggle);
if (!restore2) store2.remove(entry2.descriptor.id);
return false;
}
scheduler.register(
entry2.descriptor.id,
({ reason } = {}) => execute(entry2, reason ?? entry2.descriptor.toggle.cadence),
{
...entry2.descriptor.toggle,
onFailureThreshold: (details) => quarantine(entry2, details)
}
);
if (!restore2) store2.write(entry2.descriptor.id, true);
if (entry2.descriptor.toggle.runOnActivate !== false) {
await execute(entry2, restore2 ? "restore" : entry2.descriptor.toggle.cadence);
}
return true;
}
async function attach(descriptor, context) {
if (!descriptor.toggle) return null;
let entry2 = attached.get(descriptor.id);
if (entry2) {
entry2.context = context;
render(entry2, entry2.enabled);
return () => detach(descriptor);
}
entry2 = { descriptor, context, enabled: false };
attached.set(descriptor.id, entry2);
if (store2.read(descriptor.id)) await setEntryEnabled(entry2, true, { restore: true });
else render(entry2, false);
return () => detach(descriptor);
}
async function setEnabled(descriptor, enabled, context) {
let entry2 = attached.get(descriptor.id);
if (!entry2) {
entry2 = { descriptor, context, enabled: false };
attached.set(descriptor.id, entry2);
} else entry2.context = context;
return setEntryEnabled(entry2, enabled);
}
function detach(descriptor, { preserveIntent = true } = {}) {
const entry2 = attached.get(descriptor.id);
if (!entry2) return false;
scheduler.unregister(descriptor.id, descriptor.toggle);
if (!preserveIntent) store2.remove(descriptor.id);
attached.delete(descriptor.id);
return true;
}
async function restore() {
for (const entry2 of attached.values()) {
entry2.enabled = false;
if (store2.read(entry2.descriptor.id)) {
await setEntryEnabled(entry2, true, { restore: true });
} else render(entry2, false);
}
}
return Object.freeze({
attach,
detach,
setEnabled,
setEnabledById(id, enabled) {
const entry2 = attached.get(id);
return entry2 ? setEntryEnabled(entry2, enabled) : false;
},
restore,
isEnabled(id) {
return attached.get(id)?.enabled ?? false;
},
listAttached() {
return [...attached.keys()];
}
});
}
function createProductionCheatToggleRuntime(options6 = {}) {
return createCheatToggleRuntime({
scheduler: options6.scheduler ?? createProductionSchedulerAdapter(),
store: options6.store,
logger: options6.logger
});
}
// src/ui/shell/definitions.js
function compatibilityText(runtime) {
return runtime.testedOn && runtime.testedOn !== "0.0.0" ? `Tested on: ${runtime.testedOn}` : "Tested on: Untested";
}
function quickShell({ data, runtime }) {
const rows = [
{
key: "compatibility",
role: "help",
controls: [
{ type: "text", text: compatibilityText(runtime) },
{ type: "text", text: runtime.curVer ? `Current version: ${runtime.curVer}` : "" },
...runtime.isCheatWorkSymbol ? [{ type: "text", text: runtime.isCheatWorkSymbol }] : [],
{ type: "help", text: runtime.testedOn && runtime.testedOn !== "0.0.0" ? runtime.isCheatWork || "Compatibility information" : "Not tested in the current game version" }
]
},
{ key: "quick-heading", role: "heading", groups: ["state"], controls: [{ type: "heading", text: "Quick cheats" }] },
{ key: "unlimited-heading", role: "heading", groups: ["tasks", "unlimited", "pregnancy"], controls: [{ type: "heading", text: "Unlimited Toggles" }] }
];
if (runtime.isServer === 1) {
rows.push({ key: "server-heading", role: "heading", group: "server", controls: [{ type: "heading", text: "Server" }] });
if (runtime.curVer !== runtime.testedOn) {
rows.push({ key: "server-version-warning", role: "help", group: "server", controls: [
{ type: "text", text: "Caution: game version is different." },
{ type: "help", text: "Older or modded versions can be incompatible." }
] });
}
rows.push({ key: "server-save-actions", role: "application", group: "server", controls: [
{ type: "text", text: "Server Save" },
{ type: "action", key: "export", text: "Export", action: "save_data" },
{ type: "action", key: "import", text: "Import", action: "load_data" },
{ type: "help", text: "Export or import save slots 1\u201310 through the local server." }
] });
}
rows.push({ key: "footer", role: "footer", controls: [
{ type: "text", text: `Cheat version: ${runtime.cheatVer}${runtime.cheatVerType ? ` ${runtime.cheatVerType}` : ""}` },
{ type: "link", key: "releases", text: "GitHub Releases", href: data.releaseSite },
{ type: "link", key: "source", text: "Source Code", href: data.sourceCode }
] });
return rows;
}
var statHeadings = [
["stats-heading", "stats", "Stats"],
["enemy-heading", "enemy", "Enemy stats"],
["player-heading", "player", "Player"],
["characteristics-heading", "characteristics", "Characteristics"],
["fame-heading", "fame", "Fame"],
["school-heading", "school", "School"],
["talent-heading", "talent", "Talent"]
];
function statShell() {
return statHeadings.map(([key, group, text2]) => ({ key, groups: [group], role: "heading", controls: [{ type: "heading", text: text2 }] }));
}
function miscShell() {
return [
{ key: "npc-heading", groups: ["npc", "world"], role: "heading", controls: [{ type: "heading", text: "NPC" }] },
{ key: "pregnancy-heading", role: "heading", controls: [{ type: "heading", text: "Pregnancy Manager" }] },
{ key: "pregnancy-time-help", groups: ["pregnancy", "offspring", "pregnancy-removal"], role: "help", controls: [
{ type: "heading", text: "Pregnancy time" },
{ type: "help", text: "Values are measured in days." }
] }
];
}
function createSectionShells(context) {
return Object.freeze({ quick: Object.freeze(quickShell(context)), stats: Object.freeze(statShell()), misc: Object.freeze(miscShell()) });
}
// src/core/health.js
var STATUSES = /* @__PURE__ */ new Set(["pass", "warning", "fail", "blocked"]);
var SCOPES = /* @__PURE__ */ new Set(["catalog", "runtime", "aliases", "scheduler", "config"]);
function createDiagnosticProbe(definition) {
if (!definition || typeof definition !== "object" || Array.isArray(definition))
throw new TypeError("Diagnostic probe must be an object.");
const allowed = /* @__PURE__ */ new Set(["id", "label", "scope", "applicable", "run", "timeoutMs"]);
for (const key of Object.keys(definition))
if (!allowed.has(key)) throw new Error(`Unknown diagnostic probe field "${key}".`);
if (!/^[a-z0-9]+(?:[.-][a-z0-9]+)+$/.test(definition.id ?? ""))
throw new Error("Diagnostic probe requires a stable lowercase namespaced id.");
if (typeof definition.label !== "string" || !definition.label.trim())
throw new TypeError(`Diagnostic probe "${definition.id}" requires a label.`);
if (!SCOPES.has(definition.scope))
throw new Error(`Diagnostic probe "${definition.id}" has an invalid scope.`);
if (definition.applicable != null && typeof definition.applicable !== "function")
throw new TypeError(`Diagnostic probe "${definition.id}" applicable must be a function.`);
if (typeof definition.run !== "function")
throw new TypeError(`Diagnostic probe "${definition.id}" requires run().`);
if (!Number.isInteger(definition.timeoutMs) || definition.timeoutMs < 1)
throw new TypeError(`Diagnostic probe "${definition.id}" requires a positive timeoutMs.`);
return Object.freeze({ ...definition });
}
function safeMessage(value, fallback = "") {
return typeof value === "string" ? value.slice(0, 240) : fallback;
}
async function withTimeout(probe, context) {
let timer;
try {
return await Promise.race([
Promise.resolve().then(() => probe.run(context)),
new Promise((resolve) => {
timer = setTimeout(
() => resolve({ status: "fail", message: "Probe timed out." }),
probe.timeoutMs
);
})
]);
} finally {
clearTimeout(timer);
}
}
function formatDiagnosticReport(report) {
const lines = [
`CheatPlus diagnostics: ${report.pass} pass, ${report.warning} warning, ${report.fail} fail, ${report.blocked} blocked`
];
for (const result of report.results)
lines.push(
`${result.status.toUpperCase()} ${result.id}${result.message ? ` \u2014 ${result.message}` : ""}`
);
return lines.join("\n");
}
function createDiagnosticRunner({ probes, context = () => ({}) }) {
if (!Array.isArray(probes)) throw new TypeError("Diagnostic runner requires probes.");
const ids = /* @__PURE__ */ new Set();
for (const probe of probes) {
if (ids.has(probe.id)) throw new Error(`Duplicate diagnostic probe "${probe.id}".`);
ids.add(probe.id);
}
async function runAll() {
const results = [];
const shared = context();
for (const probe of probes) {
let result;
try {
if (probe.applicable && !await probe.applicable(shared))
result = { status: "blocked", message: "Not applicable." };
else result = await withTimeout(probe, shared);
} catch (_) {
result = { status: "fail", message: "Probe failed." };
}
const status = STATUSES.has(result?.status) ? result.status : "fail";
results.push(
Object.freeze({
id: probe.id,
label: probe.label,
scope: probe.scope,
status,
message: safeMessage(result?.message, status === "fail" ? "Invalid probe result." : "")
})
);
}
const counts = Object.fromEntries(
[...STATUSES].map((status) => [
status,
results.filter((result) => result.status === status).length
])
);
return Object.freeze({ total: results.length, ...counts, results: Object.freeze(results) });
}
return Object.freeze({ runAll, formatReport: formatDiagnosticReport, list: () => [...probes] });
}
// src/app/panel-health.js
function createProductionDiagnostics({ catalog, adapter, getHealth, getAliases, scheduler }) {
const descriptors = catalog.listCheats();
const game = createGameContext(adapter);
const probes = [
createDiagnosticProbe({
id: "catalog.identity",
label: "Catalog identity",
scope: "catalog",
timeoutMs: 250,
run: () => ({ status: new Set(descriptors.map(({ id }) => id)).size === descriptors.length ? "pass" : "fail", message: `${descriptors.length} descriptors.` })
}),
createDiagnosticProbe({
id: "runtime.paths",
label: "Runtime applicability",
scope: "runtime",
timeoutMs: 500,
applicable: () => adapter.isReady?.() !== false,
run: () => {
const missing = descriptors.filter(
({ requiredPaths = [] }) => requiredPaths.some((path7) => !game.has(path7))
).length;
return { status: missing ? "warning" : "pass", message: `${missing} descriptors have unavailable required paths.` };
}
}),
createDiagnosticProbe({
id: "builder.health",
label: "Builder health",
scope: "runtime",
timeoutMs: 250,
run: () => {
const health = getHealth();
return { status: health.failed ? "fail" : "pass", message: `${health.mounted}/${health.total} mounted; ${health.failed} failed.` };
}
}),
createDiagnosticProbe({
id: "aliases.registration",
label: "Alias registration",
scope: "aliases",
timeoutMs: 250,
run: () => {
const aliases = getAliases();
return { status: new Set(aliases).size === aliases.length ? "pass" : "fail", message: `${aliases.length} aliases registered.` };
}
}),
createDiagnosticProbe({
id: "scheduler.ownership",
label: "Scheduler ownership",
scope: "scheduler",
timeoutMs: 250,
run: () => ({ status: "pass", message: `${scheduler.list().length} scheduler entries.` })
}),
createDiagnosticProbe({
id: "config.references",
label: "Config references",
scope: "config",
timeoutMs: 250,
run: () => {
const paths = new Set(CHEAT_CONFIG_SCHEMA.map(({ path: path7 }) => path7));
const invalid = descriptors.flatMap(({ config = [] }) => config).filter((path7) => !paths.has(path7));
return { status: invalid.length ? "fail" : "pass", message: `${invalid.length} invalid config references.` };
}
})
];
return createDiagnosticRunner({ probes });
}
// src/app/game-context.js
var runtimeWindow = getRuntimeWindow();
var runtimeSugarCube = runtimeWindow?.SugarCube;
var testedOn = runtimeWindow?.testedOn ?? "0.0.0";
var cheatVer = runtimeWindow?.cheatVer ?? (true ? "3.1.0" : "dev");
var isServer = runtimeWindow?.isServer ?? 0;
var cheatVerType = runtimeWindow?.cheatVerType ?? "";
var curVer = document.getElementById(GAME_VERSION_ELEMENT_ID)?.innerHTML ?? "";
var npcnamelist = runtimeSugarCube?.setup?.NPCNameList ?? [];
if (curVer?.startsWith(".")) curVer = "0" + curVer;
// src/core/time.js
var SECONDS_PER_DAY2 = 86400;
// src/app/observers/toggle-observer-driver.js
function gameDay(timestamp) {
const value = Number(timestamp);
return Number.isFinite(value) ? Math.floor(value / SECONDS_PER_DAY2) : null;
}
function createToggleObserverDriver({
scheduler,
toggleRuntime,
getTimestamp,
logger = console
} = {}) {
if (!scheduler?.runFrame || !scheduler?.runDaily || !scheduler?.reset)
throw new TypeError("Toggle observer driver requires a runnable scheduler.");
if (!toggleRuntime?.restore)
throw new TypeError("Toggle observer driver requires the descriptor toggle runtime.");
let currentDay = gameDay(getTimestamp?.());
let restoring = null;
async function restore(reason = "runtime-restore") {
if (restoring) return restoring;
restoring = Promise.resolve().then(() => scheduler.reset()).then(() => toggleRuntime.restore()).then(() => {
currentDay = gameDay(getTimestamp?.());
return true;
}).catch((error) => {
logger?.error?.("Descriptor toggle restoration failed.", {
reason,
errorType: error?.name ?? "Error"
});
return false;
}).finally(() => {
restoring = null;
});
return restoring;
}
function notifyInteraction({ isLoad = false } = {}) {
if (isLoad || restoring) return false;
const started = scheduler.runFrame({
isLoad: false,
onWatchdogRestore: () => void restore("watchdog")
});
const nextDay = gameDay(getTimestamp?.());
if (nextDay != null && currentDay == null) currentDay = nextDay;
else if (nextDay != null && nextDay !== currentDay) {
currentDay = nextDay;
scheduler.runDaily();
}
return started;
}
return Object.freeze({
notifyInteraction,
restore,
disable(id) {
return toggleRuntime.setEnabledById?.(id, false) ?? false;
},
isEnabled(id) {
return toggleRuntime.isEnabled?.(id) ?? false;
},
stop() {
scheduler.reset();
}
});
}
// src/app/observers/active-toggle-observer.js
var activeToggleObserver = null;
function setActiveToggleObserver(observer) {
activeToggleObserver = observer ?? null;
return activeToggleObserver;
}
function getActiveToggleObserver() {
return activeToggleObserver;
}
// src/app/cheat-runtime.js
function configureCheatRuntime(runtimeEngine) {
const adapter = runtimeEngine?.adapter;
if (!adapter) throw new TypeError("Cheat runtime configuration requires an active adapter.");
const runtimeLogger = {
error: (message, data) => logger_default("cheat-runtime", message, { data, level: "error" }),
warn: (message, data) => logger_default("cheat-runtime", message, { data, level: "warn" })
};
const scheduler = createProductionSchedulerAdapter();
const toggle = createProductionCheatToggleRuntime({
logger: runtimeLogger,
scheduler,
store: createSugarCubeToggleStore()
});
setActiveToggleObserver(
createToggleObserverDriver({
scheduler,
toggleRuntime: toggle,
getTimestamp: () => adapter.getVariable?.("timeStamp"),
logger: runtimeLogger
})
);
let builder;
const diagnostics = createProductionDiagnostics({
catalog: cheatCatalog,
adapter,
getHealth: () => builder?.health() ?? { total: 0, mounted: 0, failed: 0 },
getAliases: () => [],
scheduler
});
builder = createCheatRuntimeBuilder({
catalog: cheatCatalog,
adapter,
config: createAdapterCheatConfigProvider(adapter),
document,
dispatchShellAction: dispatch,
feedback: {
success: (message) => showToast(message, { variant: "success" }),
error: (message) => showToast(message, { variant: "error" }),
warning: (message) => showToast(message, { variant: "warning" }),
info: (message) => showToast(message, { variant: "info" })
},
services: { toggle, scheduler, logger: runtimeLogger, diagnostics },
logger: {
error: (message, data) => logger_default("cheat-builder", message, { data, level: "error" })
}
});
builder.compile();
configureModalRuntimeTeardown(() => builder?.teardown());
return setActiveCheatBuilder(builder);
}
async function init_interface() {
safeCall("init_interface-start", () => {
logger_default("cheat-init", "init_interface-start");
});
const runtimeWindow2 = getRuntimeWindow();
const context = {
data: {
releaseSite,
sourceCode
},
runtime: {
testedOn: testedOn || runtimeWindow2?.testedOn,
curVer: curVer || runtimeWindow2?.curVer,
isCheatWorkSymbol: runtimeWindow2?.isCheatWorkSymbol,
isCheatWork: runtimeWindow2?.isCheatWork,
isServer: isServer || runtimeWindow2?.isServer,
cheatVer: cheatVer || runtimeWindow2?.cheatVer,
cheatVerType: cheatVerType || runtimeWindow2?.cheatVerType
}
};
safeCall(
"failed to clear existing sections",
() => {
["quick-content", "stats-content", "misc-content"].forEach((id) => {
const el = byUiId(id) || document.getElementById(id);
if (el) {
while (el.firstChild) el.removeChild(el.firstChild);
}
});
},
{
onError: (err) => {
logger_default("cheat-init", "failed to clear existing sections", { data: err, level: "warn" });
}
}
);
const shells = createSectionShells(context);
const builder = getActiveCheatBuilder();
if (builder) {
await builder.teardown();
builder.configureSections({
quick: { container: byUiId("quick-content"), rows: shells.quick },
stats: { container: byUiId("stats-content"), rows: shells.stats },
misc: { container: byUiId("misc-content"), rows: shells.misc }
});
await builder.sectionOpened("quick");
} else {
for (const section of ["quick", "stats", "misc"]) {
renderSectionShell({
section,
rows: shells[section],
container: byUiId(`${section === "stats" ? "stats" : section}-content`),
document,
dispatchAction: dispatch
});
}
}
var element = byUiId("tmpText") || document.getElementById("tmpText");
if (element) element.classList.add("tmpText");
safeCall("init_interface-done", () => {
logger_default("cheat-init", "init_interface-done");
});
}
// src/app/settings-safety.js
async function restoreVariables() {
let triggered = false;
if (getVariable("alluremod") === 0) {
setVariable("alluremod", 1);
showToast("Encounter rate enabled!");
}
const observer = getActiveToggleObserver();
if (observer?.isEnabled("quick.maximum-npc-pregnancy-rate")) {
await observer.disable("quick.maximum-npc-pregnancy-rate");
const baseline = getBaseNpcPregnancyChance();
if (Number.isFinite(baseline)) setVariable("baseNpcPregnancyChance", Math.min(baseline, 16));
showToast("NPC instant pregnant is disabled!");
triggered = true;
}
if (triggered) {
showToast("This ensure the game settings isnt break.");
showToast("You can re-enable it after youre done.");
}
}
// src/app/runtime-state.js
function getRuntime(path7) {
return get(`runtime.${path7}`);
}
function setRuntime(path7, value) {
set(`runtime.${path7}`, value);
}
function getIsLoad() {
return Boolean(getRuntime("isLoad"));
}
function setIsLoad(value) {
setRuntime("isLoad", Boolean(value));
}
// src/core/events/registry.js
var registryStore = [];
function getStore4() {
return registryStore;
}
function on(target, type, handler, options6) {
target.addEventListener(type, handler, options6);
getStore4().push({ target, type, handler, options: options6 });
}
function reset() {
const store2 = getStore4();
for (const { target, type, handler, options: options6 } of store2) {
try {
target.removeEventListener(type, handler, options6);
} catch (_) {
}
}
store2.length = 0;
}
// src/app/observers/runtime-observer-policy.js
function defaultDetectLoadTrigger(target) {
return Boolean(target?.classList?.contains("macro-button") && target?.innerHTML == "SAVES");
}
function defaultDetectHistoryNavigation(target) {
return Boolean(target?.id == "history-backward" || target?.id === "history-forward");
}
var defaultRuntimeObserverPolicy = Object.freeze({
detectLoadTrigger: defaultDetectLoadTrigger,
detectHistoryNavigation: defaultDetectHistoryNavigation
});
function createRuntimeObserverPolicy(overrides = {}) {
return {
...defaultRuntimeObserverPolicy,
...overrides
};
}
// src/app/observers/game-observers.js
var actionsRegistered = false;
var runtimeObserverPolicy = createRuntimeObserverPolicy();
function configureRuntimeObserverPolicy(overrides = {}) {
runtimeObserverPolicy = createRuntimeObserverPolicy(overrides);
}
function registerListenerActions() {
if (actionsRegistered) return;
registerApplicationShellCommands({
openModal,
showContent,
showToast,
initInterface: init_interface,
enableCheatHistory: Enable_cheat_history,
enableSidebarButton: Enable_sidebar_button,
toggleSimpleCheatButton: simple_cheat_button
});
setErrorHook((key) => showToast(`Action "${key}" failed.`, { variant: "error" }));
actionsRegistered = true;
}
function initGameObservers() {
const cheat2 = byUiId("cheat");
if (!cheat2) return;
reset();
on(document, "click", function(event) {
const target = event.target;
const observer = getActiveToggleObserver();
if (runtimeObserverPolicy.detectLoadTrigger(target)) {
setIsLoad(true);
return;
}
if (getIsLoad()) {
initStorage();
setIsLoad(false);
void observer?.restore("load").then((restored) => {
if (restored) showToast("Cheat state loaded", { variant: "success" });
});
return;
}
if (runtimeObserverPolicy.detectHistoryNavigation(target)) {
initStorage();
void observer?.restore("history");
return;
}
if (isAtSettings()) {
void restoreVariables();
return;
}
observer?.notifyInteraction();
});
on(document, "keyup", function() {
if (!isAtSettings()) getActiveToggleObserver()?.notifyInteraction({ isLoad: getIsLoad() });
});
on(cheat2, "keyup", function(event) {
event.stopPropagation();
});
}
// src/app/bootstrap.js
var bootstrapped = false;
function canBootstrap(runtimeEngine) {
return Boolean(runtimeEngine?.adapter?.isReady?.() && byUiId(CHEAT_ROOT_ID));
}
function bootstrap({ runtimeEngine } = {}) {
if (bootstrapped) return false;
if (!canBootstrap(runtimeEngine)) return false;
configureRuntimeObserverPolicy(runtimeEngine?.observerPolicy ?? {});
registerListenerActions();
configureCheatRuntime(runtimeEngine);
initStorage();
initGameObservers();
bootstrapped = true;
return true;
}
function bootstrapCheat(options6 = {}) {
return bootstrap(options6);
}
// src/app/injection.js
var injectionState = {
started: false,
ready: false
};
function getInjectionState() {
return injectionState;
}
function getDetectedRuntimeEngine() {
return ensureActiveRuntimeEngine();
}
function waitForCondition(check, { intervalMs = 50, timeoutMs = 3e4 } = {}) {
return new Promise((resolve, reject) => {
if (check()) {
resolve();
return;
}
const startedAt = Date.now();
const timer = setInterval(() => {
if (check()) {
clearInterval(timer);
resolve();
return;
}
if (Date.now() - startedAt > timeoutMs) {
clearInterval(timer);
reject(new Error("Injection prerequisites timed out."));
}
}, intervalMs);
});
}
async function waitForRuntimeEngine() {
await waitForCondition(() => Boolean(getDetectedRuntimeEngine()), { timeoutMs: 3e4 });
const runtimeEngine = getDetectedRuntimeEngine();
if (!runtimeEngine) {
throw new Error("No supported runtime engine detected.");
}
return runtimeEngine;
}
async function waitForPrerequisites(runtimeEngine) {
await waitForCondition(() => runtimeEngine.hasRuntimePrerequisites(), { timeoutMs: 3e4 }).catch(
async () => {
console.warn(
`[CheatPlus] ${runtimeEngine.label} runtime prerequisites not met within 30s \u2014 dumping status and retrying.`
);
console.warn("[CheatPlus] status:", runtimeEngine.describePrerequisiteState());
await waitForCondition(() => runtimeEngine.hasRuntimePrerequisites(), {
timeoutMs: 6e4
}).catch(async () => {
await waitForCondition(() => runtimeEngine.hasCorePrerequisites(), { timeoutMs: 6e4 });
console.warn(`[CheatPlus] Continuing with core ${runtimeEngine.label} readiness only.`);
});
}
);
}
async function startCheatInjection() {
const state = getInjectionState();
if (state.started) return;
state.started = true;
try {
logger_default("injection", "startCheatInjection:before-mount", {
data: { bodyPresent: !!document.body }
});
await waitForCondition(() => Boolean(document.body), { timeoutMs: 2e4 });
mountInterface();
logger_default("injection", "mountInterface() called", {
data: { hostPresent: !!document.getElementById(SHADOW_HOST_ID) }
});
const runtimeEngine = await waitForRuntimeEngine();
logger_default("injection", "runtime-engine-detected", {
data: { runtimeEngine: runtimeEngine.id }
});
await waitForPrerequisites(runtimeEngine);
bootstrapCheat({ runtimeEngine });
logger_default("injection", "after-bootstrap", { data: { ready: true } });
state.ready = true;
} catch (error) {
state.started = false;
console.error("[CheatPlus] Injection failed:", error);
}
}
// src/main.js
startCheatInjection();
})();