@rezless/vm 0.7.0 → 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 { 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, 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,6 +39,7 @@ import { invalidPrograms } from './typecheck.js';
  */
 export class Script {
     ast;
+    options;
     state;
     mocks = Object.create(null);
     globals;
@@ -38,22 +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 ??
@@ -67,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;
@@ -102,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),
@@ -110,9 +137,25 @@ 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,
@@ -144,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;
     }
@@ -187,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;
@@ -224,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;
@@ -280,6 +389,8 @@ 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.settle(started);
@@ -288,10 +399,170 @@ export class Script {
     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;
@@ -312,6 +583,10 @@ 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;
@@ -397,7 +672,7 @@ 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) {
@@ -408,12 +683,15 @@ export class Script {
                 this.linkset.settle([this]);
             }
         }
-        const started = this.handles(eventName) ? [this] : [];
-        if (this.task)
-            this.clockView.schedule(this.now, eventName, payload);
-        else
-            this.deliver(eventName, payload);
-        this.linkset.settle(started);
+        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
@@ -427,6 +705,55 @@ export class Script {
         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;
+        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.clockView.schedule(this.now, 'on_rez', { start_param: this.startParameter });
+    }
     boot() {
         this.started = true;
         const entry = this.handlersByState.get('default')?.get('state_entry');
@@ -461,11 +788,20 @@ export class Script {
         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;
@@ -494,8 +830,11 @@ export class Script {
             return;
         }
         const handler = this.handlersByState.get(this.state.currentState)?.get(event);
-        if (handler)
-            this.begin(handler, bindPayload(event, payload), payload);
+        if (!handler)
+            return;
+        if (DELAYED_EVENTS.has(event))
+            this.clockView.delayedUntilMs = this.now + this.clockView.minEventDelayMs;
+        this.begin(handler, bindPayload(event, payload), payload);
     }
     /** Whether the current state has a handler for `event`. */
     handles(event) {
@@ -517,6 +856,7 @@ export class Script {
         this.step({ run: this.runHandler(handler, args, payload), startedAt: this.now, wakeAt: 0 });
     }
     step(task) {
+        this.resumedAt = this.now;
         let r;
         try {
             r = task.run.next();
@@ -530,6 +870,7 @@ export class Script {
             return;
         }
         this.finish(task);
+        this.clockView.finishHandler(r.value);
         if (r.value)
             this.restart();
     }
@@ -554,10 +895,15 @@ export class Script {
      * does `state foo;` continues the chain correctly.
      */
     *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 });
+            this.state.detectedStack.push({
+                entries: detected, event: handler.name,
+            });
         try {
             this.state.memory.startEvent();
             return yield* this.runHandlerChain(handler, args);
@@ -570,6 +916,8 @@ export class Script {
         finally {
             if (pushed)
                 this.state.detectedStack.pop();
+            this.state.gameControlSnapshot = null;
+            leaveDamageEvent(payload);
         }
     }
     /** Returns true when the chain ended in llResetScript. */
@@ -583,7 +931,6 @@ export class Script {
             invalidPrograms: this.invalidPrograms,
             script: this,
             prim: this.host,
-            linkset: this.linkset,
         };
         let pending = {
             handler,
@@ -602,6 +949,8 @@ export class Script {
                     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;
@@ -626,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;
@@ -656,6 +1006,10 @@ 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();
     }