Menu
Dual Python/JavaScript adventure runtimes — always in sync
The review-first prompt is selected by default. You can switch to a direct command or download a local copy.
Read SKILL.md and any companion files shown by SkillsMP before deciding whether to install.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
npx skills add https://github.com/SimHacker/moollm --skill runtimeThe command stays on one line. Scroll horizontally to inspect it before copying.
Prefer a local copy? Download the files currently available to SkillsMP.
Based on SOC occupation classification
Showing SKILL.md
| name | runtime |
| description | Dual Python/JavaScript adventure runtimes — always in sync |
| allowed-tools | ["read_file","write_file"] |
| tier | 1 |
| protocol | DUAL-RUNTIME |
| tags | ["moollm","runtime","python","javascript","compilation","sync"] |
| related | ["context","adventure","object","expression"] |
| adversary | single-target |
"Test in Python, deploy to browser. Same semantics, both targets." — Vanessa Freudenberg (memorial voice)
The Runtime skill defines the dual Python/JavaScript adventure engines. Both runtimes:
CRITICAL: We ALWAYS generate BOTH _js AND _py code. Never one without the other.
| Runtime | Purpose |
|---|---|
| Python | Server-side, testing, LLM tethering, CLI |
| JavaScript | Browser, standalone play, offline |
# Dual Runtime Architecture
dual_runtime:
source: "YAML"
compiler: "LLM"
outputs:
guard_js: "(world) => ..."
guard_py: "lambda world: ..."
runtimes:
python:
file: "adventure.py"
targets: ["CLI", "Server"]
javascript:
file: "engine.js"
targets: ["Browser", "SPA"]
Both runtimes implement identical World classes:
class World:
"""Adventure runtime context for Python."""
def __init__(self, adventure_data: dict):
# Standard keys
self.turn = 0
self.timestamp = None
self.adventure = adventure_data
self.player = adventure_data.get('player', {})
self.room = None
self.party = adventure_data.get('party', {})
# Extended keys (set contextually)
self.object = None # During object simulation
self.target = None # During targeted action
self.npc = None # During NPC simulation
# Skill state namespaces
self.skills = DotDict() # world.skills.economy.gold
# INVENTORY
def has(self, item_id: str) -> bool:
return item_id in self.player.get('inventory', [])
def has_tag(self, tag: str) -> bool:
"""Check if player has any item with the given tag."""
for item_id in self.player.get('inventory', []):
item = self.get_object(item_id)
if item and tag in item.get('tags', []):
return True
return False
def find_by_tag(self, tag: str, in_room: bool = True) -> list:
"""Find all objects with the given tag."""
results = []
# Check inventory
for item_id in self.player.get('inventory', []):
item = self.get_object(item_id)
if item and tag in item.get('tags', []):
results.append(item)
# Check current room
if in_room and self.room:
for obj in self.room.get('objects', []):
if tag in obj.get('tags', []):
results.append(obj)
return results
def give(self, item_id: str):
inv = self.player.setdefault('inventory', [])
inv.append(item_id)
def take(self, item_id: str):
inv = self.player.get('inventory', [])
if item_id in inv:
inv.remove(item_id)
# FLAGS
def flag(self, name: str) -> bool:
return self.adventure.get('flags', {}).get(name, False)
def set_flag(self, name: str, value: bool):
flags = self.adventure.setdefault('flags', {})
flags[name] = value
# NARRATIVE
def emit(self, message: str):
self._output_queue.append(message)
def narrate(self, message: str, style: str = "normal"):
self._output_queue.append({'text': message, 'style': style})
# EVENTS
def trigger_event(self, name: str, data: dict = None):
self._event_queue.append({'name': name, 'data': data or {}})
# NAVIGATION
def go(self, destination: str):
self._pending_navigation = destination
def can_go(self, direction: str) -> bool:
exits = self.room.get('exits', {})
return direction in exits
# BUFFS
def has_buff(self, buff_id: str) -> bool:
buffs = self.player.get('buffs', [])
return any(b.get('id') == buff_id for b in buffs)
def add_buff(self, buff: dict):
buffs = self.player.setdefault('buffs', [])
buffs.append(buff)
def remove_buff(self, buff_id: str):
buffs = self.player.get('buffs', [])
self.player['buffs'] = [b for b in buffs if b.get('id') != buff_id]
# EFFECTIVE VALUES (Buff Modification Protocol)
#
# Base value = persistent truth
# Effective value = recalculated each tick
#
# "The base value is truth. The effective value is reality."
#
def reset_effective(self, obj: dict = None):
"""
Reset all effective values to their base values.
Called at the start of each tick.
"""
obj = obj or self.object
if not obj or 'state' not in obj:
return
state = obj['state']
for key in list(state.keys()):
if not key.endswith('_effective'):
effective_key = f"{key}_effective"
state[effective_key] = state[key]
def get_effective(self, obj: dict, prop: str):
"""Get effective value, falling back to base if not set."""
state = obj.get('state', {})
effective_key = f"{prop}_effective"
if effective_key in state:
return state[effective_key]
return state.get(prop)
def modify_effective(self, obj: dict, prop: str, delta):
"""Add delta to effective value."""
state = obj.get('state', {})
effective_key = f"{prop}_effective"
state[effective_key] = state.get(effective_key, state.get(prop, 0)) + delta
def multiply_effective(self, obj: dict, prop: str, factor: float):
"""Multiply effective value by factor."""
state = obj.get('state', {})
effective_key = f"{prop}_effective"
state[effective_key] = state.get(effective_key, state.get(prop, 0)) * factor
# RESILIENCE (SimCity Zone Pattern)
#
# WILL WRIGHT: "If one tile burns but the center survives,
# the zone will eventually rebuild."
#
def ensure_defaults(self, obj: dict = None) -> dict:
"""
Ensure object has its default state values.
Self-initializing: creates state if missing.
Self-healing: clamps invalid values.
"""
obj = obj or self.object
if not obj:
return {}
# Create state if missing
if 'state' not in obj:
obj['state'] = {}
# Merge defaults
defaults = obj.get('defaults', {})
for key, default_val in defaults.items():
if key not in obj['state']:
obj['state'][key] = default_val
return obj['state']
def heal_state(self, obj: dict = None):
"""
Fix inconsistent state values.
- Clamp negative numbers to 0
- Fix logical inconsistencies
"""
state = self.ensure_defaults(obj)
# Clamp numeric values to non-negative
for key, val in list(state.items()):
if isinstance(val, (int, float)) and val < 0:
state[key] = 0
return state
# STATE ACCESS
def get(self, path: str):
"""Get value by dot path: world.get('object.state.fuel')"""
parts = path.split('.')
obj = self
for part in parts:
if isinstance(obj, dict):
obj = obj.get(part)
else:
obj = getattr(obj, part, None)
if obj is None:
return None
return obj
def set(self, path: str, value):
"""Set value by dot path: world.set('object.state.lit', True)"""
parts = path.split('.')
obj = self
for part in parts[:-1]:
if isinstance(obj, dict):
obj = obj.setdefault(part, {})
else:
obj = getattr(obj, part)
if isinstance(obj, dict):
obj[parts[-1]] = value
else:
setattr(obj, parts[-1], value)
class World {
/** Adventure runtime context for JavaScript. */
constructor(adventureData) {
// Standard keys
this.turn = 0;
this.timestamp = null;
this.adventure = adventureData;
this.player = adventureData.player || {};
this.room = null;
this.party = adventureData.party || {};
// Extended keys (set contextually)
this.object = null; // During object simulation
this.target = null; // During targeted action
this.npc = null; // During NPC simulation
// Skill state namespaces
this.skills = {}; // world.skills.economy.gold
// Internal queues
this._outputQueue = [];
this._eventQueue = [];
this._pendingNavigation = null;
}
// === INVENTORY ===
has(itemId) {
return (this.player.inventory || []).includes(itemId);
}
hasTag(tag) {
/** Check if player has any item with the given tag. */
for (const itemId of this.player.inventory || []) {
const item = this.getObject(itemId);
if (item && (item.tags || []).includes(tag)) {
return true;
}
}
return false;
}
findByTag(tag, inRoom = true) {
/** Find all objects with the given tag. */
const results = [];
// Check inventory
for (const itemId of this.player.inventory || []) {
const item = this.getObject(itemId);
if (item && (item.tags || []).includes(tag)) {
results.push(item);
}
}
// Check current room
if (inRoom && this.room) {
for (const obj of this.room.objects || []) {
if ((obj.tags || []).includes(tag)) {
results.push(obj);
}
}
}
return results;
}
give(itemId) {
this.player.inventory = this.player.inventory || [];
this.player.inventory.push(itemId);
}
take(itemId) {
const inv = this.player.inventory || [];
const idx = inv.indexOf(itemId);
if (idx > -1) inv.splice(idx, 1);
}
// === FLAGS ===
flag(name) {
return (this.adventure.flags || {})[name] || false;
}
setFlag(name, value) {
this.adventure.flags = this.adventure.flags || {};
this.adventure.flags[name] = value;
}
// === NARRATIVE ===
emit(message) {
this._outputQueue.push(message);
}
narrate(message, style = "normal") {
this._outputQueue.push({ text: message, style });
}
// === EVENTS ===
triggerEvent(name, data = {}) {
this._eventQueue.push({ name, data });
}
// === NAVIGATION ===
go(destination) {
this._pendingNavigation = destination;
}
canGo(direction) {
const exits = this.room?.exits || {};
return direction in exits;
}
// === BUFFS ===
hasBuff(buffId) {
const buffs = this.player.buffs || [];
return buffs.some(b => b.id === buffId);
}
addBuff(buff) {
this.player.buffs = this.player.buffs || [];
this.player.buffs.push(buff);
}
removeBuff(buffId) {
const buffs = this.player.buffs || [];
this.player.buffs = buffs.filter(b => b.id !== buffId);
}
// === EFFECTIVE VALUES (Buff Modification Protocol) ===
//
// Base value = persistent truth
// Effective value = recalculated each tick
//
// "The base value is truth. The effective value is reality."
//
resetEffective(obj = null) {
/**
* Reset all effective values to their base values.
* Called at the start of each tick.
*/
obj = obj || this.object;
if (!obj || !obj.state) return;
const state = obj.state;
for (const key of Object.keys(state)) {
if (!key.endsWith('_effective')) {
const effectiveKey = `${key}_effective`;
state[effectiveKey] = state[key];
}
}
}
getEffective(obj, prop) {
/** Get effective value, falling back to base if not set. */
const state = obj.state || {};
const effectiveKey = `${prop}_effective`;
if (effectiveKey in state) {
return state[effectiveKey];
}
return state[prop];
}
modifyEffective(obj, prop, delta) {
/** Add delta to effective value. */
const state = obj.state || {};
const effectiveKey = `${prop}_effective`;
state[effectiveKey] = (state[effectiveKey] ?? state[prop] ?? 0) + delta;
}
multiplyEffective(obj, prop, factor) {
/** Multiply effective value by factor. */
const state = obj.state || {};
const effectiveKey = `${prop}_effective`;
state[effectiveKey] = (state[effectiveKey] ?? state[prop] ?? 0) * factor;
}
// === RESILIENCE (SimCity Zone Pattern) ===
//
// WILL WRIGHT: "If one tile burns but the center survives,
// the zone will eventually rebuild."
//
ensureDefaults(obj = null) {
/**
* Ensure object has its default state values.
* Self-initializing: creates state if missing.
* Self-healing: clamps invalid values.
*/
obj = obj || this.object;
if (!obj) return {};
// Create state if missing
obj.state = obj.state || {};
// Merge defaults
const defaults = obj.defaults || {};
for (const [key, defaultVal] of Object.entries(defaults)) {
if (!(key in obj.state)) {
obj.state[key] = defaultVal;
}
}
return obj.state;
}
healState(obj = null) {
/**
* Fix inconsistent state values.
* - Clamp negative numbers to 0
* - Fix logical inconsistencies
*/
const state = this.ensureDefaults(obj);
// Clamp numeric values to non-negative
for (const [key, val] of Object.entries(state)) {
if (typeof val === 'number' && val < 0) {
state[key] = 0;
}
}
return state;
}
// === STATE ACCESS ===
get(path) {
const parts = path.split('.');
let obj = this;
for (const part of parts) {
obj = obj?.[part];
if (obj === undefined) return undefined;
}
return obj;
}
set(path, value) {
const parts = path.split('.');
let obj = this;
for (const part of parts.slice(0, -1)) {
obj[part] = obj[part] || {};
obj = obj[part];
}
obj[parts[parts.length - 1]] = value;
}
}
Natural language compiles to BOTH targets:
# Source
guard: "player has brass-key AND room is not dark"
# Generated (BOTH always!)
guard_js: (world) => world.has("brass-key") && !world.room.is_dark
guard_py: lambda world: world.has("brass-key") and not world.room.is_dark
| Type | JavaScript | Python |
|---|---|---|
| boolean | (world) => ... | lambda world: ... |
| action | (world) => { ... } | def action(world): ... |
| method | (world, arg) => { ... } | def method(world, arg): ... |
| closure | (world) => { ... } | def closure(world): ... |
# Source
methods:
consume_fuel: "reduce fuel by amount, minimum 0"
extinguish: "set lit to false, emit darkness event"
# Generated
methods_js:
consume_fuel: (world, amount = 1) => {
world.object.state.fuel = Math.max(0, world.object.state.fuel - amount);
}
extinguish: (world) => {
world.object.state.lit = false;
world.emit("Darkness falls.");
world.triggerEvent("DARKNESS");
}
methods_py:
consume_fuel: |
def consume_fuel(world, amount=1):
world.object.state['fuel'] = max(0, world.object.state['fuel'] - amount)
extinguish: |
def extinguish(world):
world.object.state['lit'] = False
world.emit("Darkness falls.")
world.trigger_event("DARKNESS")
Both runtimes implement the same simulation loop with effective value phases:
# Simulation tick phases
simulation_tick:
- phase: 1. RESET
action: "foo_effective = foo (reset to base)"
- phase: 2. BUFFS
action: "Apply buff modifiers to _effective values"
- phase: 3. SIMULATE
action: "Objects run simulate(), modify _effective"
- phase: 4. MAIL
action: "Deliver queued messages (deterministic!)"
- phase: 5. EVENTS
action: "Process event queue"
- phase: 6. NAVIGATE
action: "Move player if requested"
- phase: 7. DISPLAY
action: "UI shows _effective with base comparison"
Messages are queued during simulation, then delivered deterministically:
# PHASE 4: Deliver mail (no LLM needed!)
for message in world.skills.postal.get('outgoing', []):
routing = message.get('routing')
# Transfer attachments
for transfer in routing.get('attachments_transfer', []):
if transfer['action'] == 'send':
move_item(world, transfer['ref'],
from_path=transfer['from_inventory'],
to_path=transfer['to_inventory'])
# Deliver to inbox
if routing['delivery_point'] == 'inbox':
add_to_inbox(world, routing['inbox_path'], message)
# Update status
message['status'] = 'delivered'
message['delivered'] = world.timestamp
# Trigger events (goal completion, etc)
for trigger in routing.get('triggers', []):
world.trigger_event(trigger['event'], trigger['data'])
world.skills.postal['outgoing'] = []
See skills/postal/ROUTING.md for full routing documentation.
# Python
def tick(world: World):
world.turn += 1
world.timestamp = datetime.now().isoformat()
# PHASE 1: Reset all effective values to base
for obj in world.room.get('objects', []):
world.reset_effective(obj)
world.reset_effective(world.player)
# PHASE 2: Apply buffs
for buff in world.player.get('buffs', []):
if buff.get('effect_py'):
exec(buff['effect_py'])(world)
# Decrement duration, remove expired buffs
if buff.get('duration'):
buff['duration'] -= 1
world.player['buffs'] = [b for b in world.player.get('buffs', [])
if b.get('duration', 1) > 0]
# PHASE 3: Simulate all objects in current room
for obj in world.room.get('objects', []):
if obj.get('simulate_py'):
world.object = obj
exec(obj['simulate_py'])(world)
world.object = None
# PHASE 4: Process event queue (actions)
for event in world._event_queue:
handle_event(world, event)
world._event_queue.clear()
# Process navigation
if world._pending_navigation:
navigate(world, world._pending_navigation)
world._pending_navigation = None
// JavaScript
function tick(world) {
world.turn += 1;
world.timestamp = new Date().toISOString();
// PHASE 1: Reset all effective values to base
for (const obj of world.room?.objects || []) {
world.resetEffective(obj);
}
world.resetEffective(world.player);
// PHASE 2: Apply buffs
for (const buff of world.player.buffs || []) {
if (buff.effect_js) {
buff.effect_js(world);
}
// Decrement duration
if (buff.duration !== undefined) {
buff.duration -= 1;
}
}
// Remove expired buffs
world.player.buffs = (world.player.buffs || [])
.filter(b => (b.duration ?? 1) > 0);
// PHASE 3: Simulate all objects in current room
for (const obj of world.room?.objects || []) {
if (obj.simulate_js) {
world.object = obj;
obj.simulate_js(world);
world.object = null;
}
}
// PHASE 4: Process event queue (actions)
for (const event of world._eventQueue) {
handleEvent(world, event);
}
world._eventQueue = [];
// Process navigation
if (world._pendingNavigation) {
navigate(world, world._pendingNavigation);
world._pendingNavigation = null;
}
}
Both runtimes should produce identical results:
# Test in Python
def test_lamp_simulation():
world = World(load_adventure())
world.room = load_room("start/")
lamp = find_object(world, "brass-lantern")
lamp.state = {"lit": True, "fuel": 2}
world.object = lamp
# Tick 1: fuel 2 → 1
exec(lamp.simulate_py)(world)
assert lamp.state["fuel"] == 1
# Tick 2: fuel 1 → 0, lamp goes out
exec(lamp.simulate_py)(world)
assert lamp.state["fuel"] == 0
assert lamp.state["lit"] == False
assert "GRUE_APPROACHES" in [e["name"] for e in world._event_queue]
Same test runs in JavaScript:
// Test in JavaScript
function testLampSimulation() {
const world = new World(loadAdventure());
world.room = loadRoom("start/");
const lamp = findObject(world, "brass-lantern");
lamp.state = { lit: true, fuel: 2 };
world.object = lamp;
// Tick 1: fuel 2 → 1
lamp.simulate_js(world);
assert(lamp.state.fuel === 1);
// Tick 2: fuel 1 → 0, lamp goes out
lamp.simulate_js(world);
assert(lamp.state.fuel === 0);
assert(lamp.state.lit === false);
assert(world._eventQueue.some(e => e.name === "GRUE_APPROACHES"));
}
DUAL-RUNTIME — Python + JavaScript, always in sync