@rezless/vm 0.6.2 → 0.8.0

package/dist/script.js

@@ -1,23 +1,37 @@
+import { clearTargetMotion } from './builtins/motion.js';
+import { copyGameControl, gameControlAvatars } from './builtins/game-control.js';
+import { PERMISSION_GAME_CONTROL } from './generated/constants.js';
+import { clearTargets } from './builtins/targets.js';
+import { withCollisionFilter } from './builtins/collision.js';
+import { stopSensors } from './builtins/sensor.js';
+import { enterDamageEvent, leaveDamageEvent, combatAvatars, } from './builtins/damage.js';
+import { sendIncomingHttp } from './builtins/http.js';
+import { deliverEmail, emailQueue } from './builtins/email.js';
+import { characterFor, pathUpdate, setNavigationResults } from './builtins/pathfinding.js';
 import { truncateUtf8 } from './values/utf8.js';
-import { ResetScriptSignal } from './builtins/object.js';
-import { ScriptRemovedSignal } from './builtins/inventory.js';
+import { agentPresence } from './builtins/viewer.js';
+import { defaultCamera } from './builtins/camera.js';
+import { animationAvatars, playingAnimations, setAnimationState } from './builtins/animation.js';
+import { HaltSignal, ResetScriptSignal } from './builtins/object.js';
 import { Mulberry32 } from './random.js';
 import { inventoryItemName } from './inventory.js';
+import { typedList, listElementTypes } from './values/list-types.js';
 import { NULL_KEY } from './values/types.js';
 import { execHandler, StateChangeSignal } from './interpreter.js';
 import { buildCoveragePlan, CoverageCollector } from './coverage.js';
 import { defaultEvalFor, rot, toFloat32Value, vec } from './values/types.js';
-import { typedList } from './values/list-types.js';
 import { Env } from './env.js';
-import { ScriptClockView } from './clock.js';
+import { DELAYED_EVENTS, ScriptClockView } from './clock.js';
 import { Linkset } from './linkset.js';
 import { Prim } from './prim.js';
 import { EVENT_SPECS } from './generated/events.js';
 import { CONSTANT_TABLE } from './generated/constants_table.js';
-import { DEBUG_CHANNEL, HTTP_BODY_TRUNCATED } from './generated/constants.js';
+import { DEBUG_CHANNEL, HTTP_BODY_TRUNCATED, PERMISSION_TAKE_CONTROLS, XP_ERROR_NOT_PERMITTED, } from './generated/constants.js';
 import { own } from './own.js';
 import { deterministicKey } from './keys.js';
-import { Memory, StackHeapCollision, codeBytes } from './memory.js';
+import { Memory, RuntimeError, codeBytes } from './memory.js';
+import { invalidPrograms } from './typecheck.js';
+import { grantExperience } from './builtins/experience.js';
 /**
  * Public handle for a loaded LSL script. Tests interact almost entirely
  * with this surface: drive events via fire(), inspect chat / calls,
@@ -25,11 +39,13 @@ import { Memory, StackHeapCollision, codeBytes } from './memory.js';
  */
 export class Script {
     ast;
+    options;
     state;
     mocks = Object.create(null);
     globals;
     userFunctions;
     functions;
+    invalidPrograms;
     handlersByState;
     started = false;
     stubs;
@@ -37,20 +53,28 @@ export class Script {
     /** Per-script clock facade (timer state + time reference). */
     clockView;
     host;
-    linkset;
     scriptName;
     /** When false, drainQueue parks events instead of delivering them. */
     running = true;
     /** Events parked while `running === false`; replayed when re-enabled. */
     parkedEvents = [];
+    /** llGetStartParameter: the linkset's start parameter until the script resets, then 0. */
+    startParameter;
+    /** The handler chain suspended in llSleep or a builtin delay, if any. */
+    task = null;
+    /** Virtual time this script last started a handler or woke from a sleep. */
+    resumedAt = 0;
     constructor(ast, options = {}) {
         this.ast = ast;
+        this.options = options;
         // Auto-wrap: if no host prim was provided, create a default 1-prim linkset.
         let host = options.host;
         if (!host) {
             const linkset = new Linkset({
                 owner: options.owner ?? NULL_KEY,
                 startUnixTime: options.startUnixTime ?? 0,
+                startParameter: options.startParameter ?? 0,
+                startString: options.startString ?? '',
             });
             const prim = new Prim({
                 key: options.objectKey ??
@@ -64,15 +88,14 @@ export class Script {
         if (!host.linkset) {
             throw new Error('Script host prim must belong to a Linkset');
         }
-        this.linkset = host.linkset;
+        this.startParameter = this.linkset.startParameter;
         this.scriptName = inventoryItemName(options.scriptName ?? deriveScriptName(options.filename));
         this.clockView = new ScriptClockView(this.linkset.clock, () => this);
-        const linkset = this.linkset;
         const prim = host;
         const scriptName = this.scriptName;
         const identity = {
             get owner() {
-                return linkset.owner;
+                return prim.linkset.owner;
             },
             get objectKey() {
                 return prim.key;
@@ -99,6 +122,13 @@ export class Script {
             clock: this.clockView,
             httpRequests: [],
             httpKeyCounter: 0,
+            urls: [],
+            urlPolicy: 'grant',
+            urlCounter: 0,
+            incomingHttp: [],
+            httpInCounter: 0,
+            emails: [],
+            targetedEmails: [],
             listens: [],
             listenHandleCounter: 0,
             random: new Mulberry32(options.randomSeed ?? 1),
@@ -107,11 +137,29 @@ export class Script {
             dataserverRequests: [],
             dataserverKeyCounter: 0,
             detectedStack: [],
-            linksetData: this.linkset.linksetData,
+            get linksetData() {
+                return prim.linkset.linksetData;
+            },
             appearance: this.host.appearance,
+            gameControlSnapshot: null,
             permissions: { granted: 0, agent: NULL_KEY, requests: [] },
+            experience: options.experience ?? null,
+            experienceRequests: [],
+            controls: { taken: null, level: 0 },
+            camera: defaultCamera(),
+            cameraParams: new Map(),
+            get animations() {
+                return animationAvatars(prim.linkset);
+            },
+            inventoryOffers: [],
+            viewerRequests: [],
+            teleportRequests: [],
+            agentPresence: agentPresence(prim.linkset),
+            dialogs: [],
             lifecycle: {
                 dead: false,
+                dying: false,
+                removed: false,
             },
             filename,
             source,
@@ -127,6 +175,7 @@ export class Script {
         initGlobals(this.globals, ast.globals);
         this.userFunctions = new Map(ast.functions.map((f) => [f.name, f]));
         this.functions = options.functions ?? {};
+        this.invalidPrograms = invalidPrograms(ast, this.functions);
         this.stubs = options.stubs ?? 'allow';
         this.handlersByState = indexHandlers(ast);
         if (!this.handlersByState.has('default')) {
@@ -138,7 +187,21 @@ export class Script {
             host.addScript(this);
         }
     }
+    /** A state transition leaves on_damage before lifecycle handlers execute. */
+    clearDamageAdjustment() {
+        const context = this.state.detectedStack.at(-1);
+        if (context?.event === 'on_damage')
+            context.event = '';
+    }
+    /** Configure an avatar's combat health, parcel and attachment scripts. */
+    setCombatAvatar(id, avatar) {
+        combatAvatars(this).set(id.toLowerCase(), { ...avatar, region: this.linkset.region });
+    }
     /** Current virtual time in milliseconds since linkset construction. */
+    /** The linkset holding this script's prim; it changes when the prim is linked or unlinked. */
+    get linkset() {
+        return this.host.linkset;
+    }
     get now() {
         return this.linkset.clock.now;
     }
@@ -181,6 +244,18 @@ export class Script {
     callsOf(name) {
         return this.state.calls.filter((c) => c.name === name);
     }
+    /** The object's character, or null before creation and after deletion. */
+    get character() {
+        return characterFor(this);
+    }
+    /** Set fixed navigation query answers. These fixtures survive script resets. */
+    setNavigationResults(results) {
+        setNavigationResults(this, results);
+    }
+    /** Raise path_update on every script in the character's root prim. */
+    pathUpdate(type, reserved = []) {
+        pathUpdate(this, type, reserved);
+    }
     /** Captured outgoing HTTP requests from `llHTTPRequest`. */
     get httpRequests() {
         return this.state.httpRequests;
@@ -206,9 +281,10 @@ export class Script {
                 : typedList([HTTP_BODY_TRUNCATED, req.bodyMaxLength], ['integer', 'integer']),
             body: cut,
         };
+        const started = this.host.scripts.filter((s) => s.handles('http_response'));
         for (const s of this.host.scripts)
             this.clockView.scheduleOn(s, this.now, 'http_response', payload);
-        this.linkset.drainQueue();
+        this.linkset.settle(started);
     }
     /** Convenience: respond to the most recent HTTP request. */
     respondToLastHttp(response) {
@@ -217,6 +293,46 @@ export class Script {
             throw new Error('no HTTP request to respond to');
         this.respondToHttp(req.key, response);
     }
+    /** URLs the script holds from llRequestURL / llRequestSecureURL, oldest first. */
+    get urls() {
+        return this.state.urls;
+    }
+    /** Grant later llRequestURL / llRequestSecureURL calls (the default). */
+    grantUrls() {
+        this.state.urlPolicy = 'grant';
+    }
+    /** Deny later llRequestURL / llRequestSecureURL calls with URL_REQUEST_DENIED. */
+    denyUrls() {
+        this.state.urlPolicy = 'deny';
+    }
+    /**
+     * Send a request to one of the script's URLs, with a path and query after
+     * it if you like, and fire `http_request`. The returned request's
+     * `response` holds what the script answered with llHTTPResponse.
+     */
+    sendHttpRequest(url, init = {}) {
+        return sendIncomingHttp(this, this.state, url, init);
+    }
+    /** Mail the script sent with llEmail, oldest first. */
+    get emails() {
+        return this.state.emails;
+    }
+    /** Mail the script sent with llTargetedEmail, oldest first. */
+    get targetedEmails() {
+        return this.state.targetedEmails;
+    }
+    /** Mail queued on the script's prim, oldest first, waiting for llGetNextEmail. */
+    get inbox() {
+        return emailQueue(this.host);
+    }
+    /**
+     * Queue mail on the script's prim. It fires `email` only when a script in
+     * the prim asks for it with llGetNextEmail. Returns false, queuing
+     * nothing, when the prim already holds 101 mails.
+     */
+    deliverEmail(init) {
+        return deliverEmail(this, init);
+    }
     /** Currently active listen registrations (from `llListen`). */
     get listens() {
         return this.state.listens;
@@ -244,9 +360,10 @@ export class Script {
             throw new Error(`unknown dataserver request key: ${key}`);
         req.fulfilled = true;
         const payload = { queryid: key, data: value };
+        const started = this.host.scripts.filter((s) => s.handles('dataserver'));
         for (const s of this.host.scripts)
             this.clockView.scheduleOn(s, this.now, 'dataserver', payload);
-        this.linkset.drainQueue();
+        this.linkset.settle(started);
     }
     /** Convenience: respond to the most recent dataserver request. */
     respondToLastDataserver(value) {
@@ -272,17 +389,180 @@ export class Script {
         const granted = req.permissions & (permissions ?? req.permissions);
         this.state.permissions.granted = granted;
         this.state.permissions.agent = req.agent;
+        if (!(granted & PERMISSION_TAKE_CONTROLS))
+            this.state.controls.taken = null;
+        const started = this.handles('run_time_permissions') ? [this] : [];
         this.clockView.schedule(this.now, 'run_time_permissions', { perm: granted });
-        this.linkset.drainQueue();
+        this.linkset.settle(started);
     }
     /** Answer the most recent unanswered permission request with No. */
     denyPermissions() {
         this.grantPermissions(0);
     }
+    /** The experience the script was compiled with, or null. */
+    get experience() {
+        return this.state.experience;
+    }
+    /** llRequestExperiencePermissions calls waiting for an answer, oldest first. */
+    get experienceRequests() {
+        return this.state.experienceRequests;
+    }
+    /**
+     * Accept the most recent unanswered llRequestExperiencePermissions: the
+     * agent joins the experience, the script holds the experience permissions
+     * for that agent, and `experience_permissions` fires.
+     */
+    grantExperiencePermissions() {
+        const req = this.answerExperienceRequest();
+        const started = this.handles('experience_permissions') ? [this] : [];
+        grantExperience(this.state, req.agent);
+        this.linkset.settle(started);
+    }
+    /**
+     * Decline the most recent unanswered llRequestExperiencePermissions:
+     * `experience_permissions_denied` fires with `reason`
+     * (XP_ERROR_NOT_PERMITTED by default).
+     */
+    denyExperiencePermissions(reason = XP_ERROR_NOT_PERMITTED) {
+        const req = this.answerExperienceRequest();
+        this.fireAndSettle('experience_permissions_denied', { agent_id: req.agent, reason });
+    }
+    answerExperienceRequest() {
+        const req = [...this.state.experienceRequests].reverse().find((r) => !r.answered);
+        if (!req)
+            throw new Error('no pending experience permission request');
+        req.answered = true;
+        return req;
+    }
+    fireAndSettle(event, payload) {
+        const started = this.handles(event) ? [this] : [];
+        this.clockView.schedule(this.now, event, payload);
+        this.linkset.settle(started);
+    }
+    /** Controls taken with llTakeControls, or null when none are. */
+    get controls() {
+        return this.state.controls.taken;
+    }
+    /**
+     * Have the permission agent hold exactly the controls in `level` (CONTROL_*
+     * bits; 0 lets go of all). Fires `control` with the held and just-changed
+     * bits among those taken, if the script took controls with accept TRUE and
+     * any of them is held or changed.
+     */
+    sendControl(level) {
+        const edge = level ^ this.state.controls.level;
+        this.state.controls.level = level;
+        const taken = this.state.controls.taken;
+        if (!taken?.accept)
+            return;
+        const held = level & taken.controls;
+        const changed = edge & taken.controls;
+        if (held === 0 && changed === 0)
+            return;
+        const started = this.handles('control') ? [this] : [];
+        this.clockView.schedule(this.now, 'control', { id: this.state.permissions.agent, level: held, edge: changed });
+        this.linkset.settle(started);
+    }
+    /** Set an avatar's semantic input fixture, shared by scripts in this World. */
+    setGameControl(agent, input) {
+        const avatars = gameControlAvatars(this.linkset);
+        if (input === null)
+            avatars.delete(agent.toLowerCase());
+        else
+            avatars.set(agent.toLowerCase(), copyGameControl(input));
+    }
+    /** Queue raw input and a copy of the avatar's semantic fixture for this script. */
+    sendGameControl(agent, raw = {}) {
+        if (!(this.state.permissions.granted & PERMISSION_GAME_CONTROL)
+            || agent.toLowerCase() !== this.state.permissions.agent.toLowerCase())
+            return;
+        const input = gameControlAvatars(this.linkset).get(agent.toLowerCase());
+        const snapshot = input ? { ...copyGameControl(input), agent: agent.toLowerCase() } : null;
+        this.fire('game_control', {
+            id: agent, button_levels: (raw.buttons ?? 0) | 0,
+            axes: typedList((raw.axes ?? []).map(Math.fround), (raw.axes ?? []).map(() => 'float')),
+            gameControlSnapshot: snapshot,
+        });
+    }
+    /** Set the permission agent's camera that llGetCameraPos / Rot / FOV / Aspect report. */
+    setCamera(camera) {
+        const { pos, rot: r, fov, aspect } = { ...this.state.camera, ...camera };
+        this.state.camera = {
+            pos: vec(pos.x, pos.y, pos.z),
+            rot: rot(r.x, r.y, r.z, r.s),
+            fov: Math.fround(fov),
+            aspect: Math.fround(aspect),
+        };
+    }
+    /** Camera rules set with llSetCameraParams, by rule. */
+    get cameraParams() {
+        return this.state.cameraParams;
+    }
+    /** Register an avatar in this region and set its default locomotion animation. */
+    setAnimationState(agent, state) {
+        setAnimationState(this.state.animations, agent, state);
+    }
+    /** Playing animation UUIDs for an avatar, in UUID order. Returns a fresh array. */
+    getPlayingAnimations(agent) {
+        return playingAnimations(this.state.animations, agent);
+    }
+    /** Inventory offers and completed prim deliveries, oldest first. */
+    get inventoryOffers() {
+        return this.state.inventoryOffers;
+    }
+    /** Teleport attempts made by this script, oldest first. */
+    get teleportRequests() {
+        return this.state.teleportRequests;
+    }
+    /** URL/map requests and rejected floater calls, oldest first. */
+    get viewerRequests() {
+        return this.state.viewerRequests;
+    }
+    /** Override whether an avatar is present in this region, for every script sharing it. */
+    setAgentInRegion(agent, present = true) {
+        this.state.agentPresence.set(agent.toLowerCase(), present);
+    }
+    /** Dialogs and text boxes this script showed with llDialog / llTextBox, oldest first. */
+    get dialogs() {
+        return this.state.dialogs;
+    }
+    /**
+     * Answer a dialog as its avatar: the most recent unanswered one, or
+     * `opts.dialog`. The avatar says `text` on the dialog's channel, heard by
+     * listens within 20 m of the prim that showed it. A llDialog answer must
+     * be one of its buttons; a text box takes any text.
+     */
+    answerDialog(text, opts = {}) {
+        const dialog = opts.dialog ?? [...this.state.dialogs].reverse().find((d) => !d.answered);
+        if (!dialog)
+            throw new Error('no unanswered dialog');
+        if (!this.state.dialogs.includes(dialog))
+            throw new Error('that dialog was not shown by this script');
+        if (dialog.answered)
+            throw new Error('that dialog was already answered');
+        if (dialog.kind === 'dialog' && !dialog.buttons.includes(text)) {
+            throw new Error(`'${text}' is not a button on the dialog: ${dialog.buttons.join(', ')}`);
+        }
+        dialog.answered = true;
+        const chat = { channel: dialog.channel, name: opts.name ?? '', key: dialog.agent, message: text };
+        this.linkset.settle(this.linkset.routeAvatarChat(this.host, chat).filter((s) => s.handles('listen')));
+    }
     /** Currently displayed floating text (from llSetText). null if unset. */
     get text() {
         return this.state.appearance.text;
     }
+    /** The prim's llSetTouchText text, '' if unset. */
+    get touchText() {
+        return this.host.touchText;
+    }
+    /** The prim's llSetSitText text, '' if unset. */
+    get sitText() {
+        return this.host.sitText;
+    }
+    /** The prim's llSetPayPrice arguments, null if unset. */
+    get payPrice() {
+        return this.host.payPrice;
+    }
     /** Object description from llSetObjectDesc. */
     get objectDesc() {
         return this.state.appearance.description;
@@ -303,13 +583,17 @@ export class Script {
             this.state.linksetData.set(k, { value: v.value, password: v.password ?? '' });
         }
     }
+    /** The script's memory limit in bytes, as llGetMemoryLimit reads it. */
+    get memoryLimit() {
+        return this.state.memory.limit;
+    }
     /** True once `llDie()` has been called. Subsequent fire() calls are no-ops. */
     get dead() {
         return this.state.lifecycle.dead;
     }
     /**
-     * Match chat against this script's listens and queue `listen` events for
-     * every match. Does not drain — caller does that. Used by Linkset.deliverChat
+     * Match chat against this script's listens and queue one `listen` event
+     * if any of them match; returns whether one did. Does not drain — caller does that. Used by Linkset.deliverChat
      * for cross-script delivery.
      */
     matchChatListens(opts) {
@@ -330,15 +614,16 @@ export class Script {
                 id: opts.key,
                 msg: opts.message,
             });
+            return true;
         }
+        return false;
     }
     /**
      * Deliver chat to this script only. Linkset-wide delivery (every listening
      * script in the linkset) is `linkset.deliverChat`.
      */
     deliverChat(opts) {
-        this.matchChatListens(opts);
-        this.linkset.drainQueue();
+        this.linkset.settle(this.matchChatListens(opts) && this.handles('listen') ? [this] : []);
     }
     /**
      * Override an `ll*` function for the lifetime of this Script. Replaces
@@ -375,7 +660,10 @@ export class Script {
      *
      * Synchronous: runs the handler to completion before returning, including
      * any state transitions triggered by `state foo;` (state_exit / change /
-     * state_entry chain runs before fire() returns).
+     * state_entry chain runs before fire() returns). A handler that sleeps
+     * moves the clock to its wake time, running every other script's due
+     * events on the way. A script already sleeping handles the event after
+     * its current handler.
      *
      * If the current state has no handler for `eventName`, this is a no-op
      * — matches LSL behavior of silently dropping unhandled events.
@@ -384,23 +672,26 @@ export class Script {
         if (this.state.lifecycle.dead)
             return;
         if (!this.running) {
-            this.parkedEvents.push({ at: this.now, event: eventName, payload });
+            withCollisionFilter(this, eventName, payload, p => this.parkedEvents.push({ at: this.now, event: eventName, payload: p }));
             return;
         }
         if (!this.started) {
             this.started = true;
             const entry = this.handlersByState.get(this.state.currentState)?.get('state_entry');
             if (entry && eventName !== 'state_entry') {
-                this.runHandler(entry, []);
-                this.linkset.drainQueue();
+                this.begin(entry, [], {});
+                this.linkset.settle([this]);
             }
         }
-        const handler = this.handlersByState.get(this.state.currentState)?.get(eventName);
-        if (handler) {
-            const args = bindPayload(eventName, payload);
-            this.withDetected(payload, () => this.runHandler(handler, args));
-        }
-        this.linkset.drainQueue();
+        withCollisionFilter(this, eventName, payload, p => {
+            const started = this.handles(eventName) ? [this] : [];
+            if (this.task || (DELAYED_EVENTS.has(eventName) && this.clockView.delayedUntilMs > this.now)) {
+                this.clockView.schedule(this.now, eventName, p);
+            }
+            else
+                this.deliver(eventName, p);
+            this.linkset.settle(started);
+        });
     }
     /**
      * Run state_entry of the default state. If the script has been auto-started
@@ -411,38 +702,106 @@ export class Script {
             return;
         if (this.started)
             return;
+        this.boot();
+        this.linkset.settle([this]);
+    }
+    /** Queue a fresh inventory script's first event without waiting for its handler. */
+    queueStart() {
+        if (this.started || this.dead)
+            return;
         this.started = true;
-        const entry = this.handlersByState.get('default')?.get('state_entry');
-        if (entry) {
-            this.runHandler(entry, []);
+        this.clockView.schedule(this.now, 'state_entry');
+    }
+    /** Copy inventory code; fresh copies omit saved runtime state for remote loading. */
+    copyTo(host, opts = {}) {
+        const copy = new Script(this.ast, { ...this.options, host, coverage: false });
+        Object.assign(copy.mocks, this.mocks);
+        copy.state.coverage = this.state.coverage;
+        if (opts.fresh)
+            return copy;
+        for (const g of this.ast.globals) {
+            const value = this.global(g.name);
+            const saved = Array.isArray(value)
+                ? typedList(structuredClone(value), listElementTypes(value) ?? [])
+                : structuredClone(value);
+            copy.setGlobal(g.name, saved);
+        }
+        copy.state.memory.limit = this.state.memory.limit;
+        copy.state.currentState = this.state.currentState;
+        copy.started = this.started;
+        copy.running = this.running && !this.dead;
+        Object.assign(copy.state.random, this.state.random);
+        copy.state.listens.push(...structuredClone(this.state.listens));
+        copy.state.listenHandleCounter = this.state.listenHandleCounter;
+        copy.clockView.timerIntervalMs = this.clockView.timerIntervalMs;
+        copy.clockView.timerNextFireMs = copy.now + Math.max(0, this.clockView.timerNextFireMs - this.now);
+        copy.clockView.timeReferenceMs = copy.now - (this.now - this.clockView.timeReferenceMs);
+        copy.clockView.minEventDelayMs = this.clockView.minEventDelayMs;
+        for (const kind of ['move', 'look']) {
+            const request = host.linkset.prims[0].targetMotion[kind];
+            if (request?.owner.prim === this.host.key && request.owner.script === this.scriptName)
+                request.owner.prim = host.key;
+        }
+        return copy;
+    }
+    /** Queue rez lifecycle events after restoring the inventory script's saved data. */
+    queueRez() {
+        if (!this.running)
+            return;
+        if (!this.started) {
+            this.started = true;
+            this.clockView.schedule(this.now, 'state_entry');
         }
-        this.linkset.drainQueue();
+        this.clockView.schedule(this.now, 'on_rez', { start_param: this.startParameter });
+    }
+    boot() {
+        this.started = true;
+        const entry = this.handlersByState.get('default')?.get('state_entry');
+        if (entry)
+            this.begin(entry, [], {});
     }
     /**
      * Reset the script as if `llResetScript` had been called: clear globals,
      * reseed them from the AST initializers, return to the default state,
      * cancel timers, and run state_entry. Used internally when llResetScript
      * is invoked from inside a handler; tests can also call it directly.
+     * A sleeping handler is abandoned.
      */
     reset() {
+        this.restart();
+        this.linkset.settle([this]);
+    }
+    restart() {
+        this.abandon();
         this.state.memory.releaseStack();
         this.globals.clear();
         try {
             initGlobals(this.globals, this.ast.globals);
         }
         catch (e) {
-            if (e instanceof StackHeapCollision)
+            if (e instanceof RuntimeError)
                 this.crash(e);
             throw e;
         }
         this.state.currentState = 'default';
         this.state.lifecycle.dead = false;
+        this.state.lifecycle.dying = false;
+        this.state.lifecycle.removed = false;
         this.state.listens.length = 0;
+        this.state.urls.length = 0;
         this.state.permissions.granted = 0;
         this.state.permissions.agent = NULL_KEY;
         for (const r of this.state.permissions.requests)
             r.answered = true;
+        for (const r of this.state.experienceRequests)
+            r.answered = true;
+        this.state.controls.taken = null;
+        stopSensors(this);
+        clearTargets(this);
+        clearTargetMotion(this);
         this.clockView.cancelTimer();
+        this.clockView.setMinEventDelay(0);
+        this.startParameter = 0;
         this.clockView.resetReference();
         this.linkset.clock.purgeTarget(this);
         this.parkedEvents.length = 0;
@@ -454,10 +813,9 @@ export class Script {
         if (this.state.coverage)
             this.state.coverage.hitState('default');
         // Per LSL: if the script is stopped, reset just clears state — no
-        // state_entry runs until it's restarted. If it's running, fire
-        // state_entry now via start().
+        // state_entry runs until it's restarted.
         if (this.running)
-            this.start();
+            this.boot();
     }
     /**
      * Internal: invoked by `Linkset.drainQueue` to deliver one queued event.
@@ -468,33 +826,64 @@ export class Script {
         if (this.state.lifecycle.dead)
             return;
         if (event === '__reset') {
-            this.reset();
+            this.restart();
             return;
         }
         const handler = this.handlersByState.get(this.state.currentState)?.get(event);
         if (!handler)
             return;
-        const args = bindPayload(event, payload);
-        this.withDetected(payload, () => this.runHandler(handler, args));
+        if (DELAYED_EVENTS.has(event))
+            this.clockView.delayedUntilMs = this.now + this.clockView.minEventDelayMs;
+        this.begin(handler, bindPayload(event, payload), payload);
     }
-    /**
-     * Push a detected context (if the payload includes `detected`) for the
-     * duration of `fn`, so llDetectedKey / Name / Pos / etc. inside the
-     * handler resolve to the right entries.
-     */
-    withDetected(payload, fn) {
-        const detected = payload['detected'];
-        if (!Array.isArray(detected) || detected.length === 0) {
-            fn();
+    /** Whether the current state has a handler for `event`. */
+    handles(event) {
+        return this.handlersByState.get(this.state.currentState).has(event);
+    }
+    /** Virtual time a sleeping handler wakes at, or undefined when the script is idle. */
+    get wakeAt() {
+        return this.task?.wakeAt;
+    }
+    /** Internal: invoked by `Linkset.drainQueue` when a sleeping handler's wake time comes. */
+    wake() {
+        const task = this.task;
+        if (!task)
             return;
-        }
-        this.state.detectedStack.push({ entries: detected });
+        this.task = null;
+        this.step(task);
+    }
+    begin(handler, args, payload) {
+        this.step({ run: this.runHandler(handler, args, payload), startedAt: this.now, wakeAt: 0 });
+    }
+    step(task) {
+        this.resumedAt = this.now;
+        let r;
         try {
-            fn();
+            r = task.run.next();
         }
-        finally {
-            this.state.detectedStack.pop();
+        catch (e) {
+            this.finish(task);
+            throw e;
+        }
+        if (!r.done) {
+            this.task = { ...task, wakeAt: r.value.until };
+            return;
         }
+        this.finish(task);
+        this.clockView.finishHandler(r.value);
+        if (r.value)
+            this.restart();
+    }
+    finish(task) {
+        if (this.now === task.startedAt)
+            return;
+        this.clockView.busyUntilMs = this.now;
+        this.linkset.clock.requeue(this);
+    }
+    abandon() {
+        const task = this.task;
+        this.task = null;
+        task?.run.return(false);
     }
     /**
      * Run a handler and process any state-change signal it raises.
@@ -505,34 +894,43 @@ export class Script {
      * with a small loop so that a `state_exit` or `state_entry` that itself
      * does `state foo;` continues the chain correctly.
      */
-    runHandler(handler, args) {
-        if (this.state.lifecycle.dead)
-            return;
-        const startedAt = this.now;
+    *runHandler(handler, args, payload) {
+        this.state.gameControlSnapshot = handler.name === 'game_control'
+            ? payload['gameControlSnapshot'] ?? null : null;
+        enterDamageEvent(payload);
+        const detected = payload['detected'];
+        const pushed = Array.isArray(detected) && detected.length > 0;
+        if (pushed)
+            this.state.detectedStack.push({
+                entries: detected, event: handler.name,
+            });
         try {
             this.state.memory.startEvent();
-            this.runHandlerChain(handler, args);
+            return yield* this.runHandlerChain(handler, args);
         }
         catch (e) {
-            if (e instanceof StackHeapCollision)
+            if (e instanceof RuntimeError)
                 this.crash(e);
             throw e;
         }
         finally {
-            if (this.now > startedAt)
-                this.clockView.busyUntilMs = this.now;
+            if (pushed)
+                this.state.detectedStack.pop();
+            this.state.gameControlSnapshot = null;
+            leaveDamageEvent(payload);
         }
     }
-    runHandlerChain(handler, args) {
+    /** Returns true when the chain ended in llResetScript. */
+    *runHandlerChain(handler, args) {
         const ctx = {
             state: this.state,
             mocks: this.mocks,
             globals: this.globals,
             userFunctions: this.userFunctions,
             functions: this.functions,
+            invalidPrograms: this.invalidPrograms,
             script: this,
             prim: this.host,
-            linkset: this.linkset,
         };
         let pending = {
             handler,
@@ -542,28 +940,30 @@ export class Script {
             const { handler: h, args: a } = pending;
             pending = null;
             try {
-                execHandler(ctx, h, a);
+                yield* execHandler(ctx, h, a);
             }
             catch (e) {
-                if (e instanceof ResetScriptSignal) {
-                    this.reset();
-                    return;
-                }
-                if (e instanceof ScriptRemovedSignal)
-                    return;
+                if (e instanceof ResetScriptSignal)
+                    return true;
+                if (e instanceof HaltSignal)
+                    return false;
                 if (!(e instanceof StateChangeSignal))
                     throw e;
+                this.state.gameControlSnapshot = null;
+                this.clearDamageAdjustment();
+                if (this.state.lifecycle.removed)
+                    return false;
                 const target = e.target;
                 if (target === this.state.currentState || this.state.lifecycle.dead)
                     continue;
                 const exit = this.handlersByState.get(this.state.currentState)?.get('state_exit');
                 if (exit) {
                     try {
-                        execHandler(ctx, exit, []);
+                        yield* execHandler(ctx, exit, []);
                     }
                     catch (e2) {
-                        if (e2 instanceof ScriptRemovedSignal)
-                            return;
+                        if (e2 instanceof HaltSignal)
+                            return false;
                         if (e2 instanceof StateChangeSignal) {
                             // Discard further changes inside state_exit per LSL convention.
                         }
@@ -575,6 +975,7 @@ export class Script {
                 if (!this.handlersByState.has(target)) {
                     throw new Error(`unknown state '${target}' in state change`);
                 }
+                stopSensors(this);
                 this.state.listens.length = 0;
                 this.linkset.clock.purgeTarget(this, this.now, '__reset');
                 this.state.currentState = target;
@@ -586,6 +987,7 @@ export class Script {
                 }
             }
         }
+        return false;
     }
     /** Stop the script after a fatal run-time error, reporting it on DEBUG_CHANNEL. */
     crash(error) {
@@ -604,7 +1006,12 @@ export class Script {
      */
     markDead() {
         this.state.lifecycle.dead = true;
+        this.state.urls.length = 0;
+        stopSensors(this);
+        clearTargets(this);
+        clearTargetMotion(this);
         this.clockView.cancelTimer();
+        this.abandon();
     }
     /**
      * Replay any events parked while this script was disabled. Caller is