Function Reference

Broadcasts a message on the specified channel within 20m range. Channel 0 is public chat visible to all nearby avatars.

// Greet anyone nearby on public chat
this.say(0, "Hello, world!");

// Send data on a private channel
this.say(42, "secret-handshake:confirmed");

Sends a message on the specified channel with a 10m range — half the range of say.

// Whisper a hint to nearby avatars
this.whisper(0, "Psst... click the red button.");

Shouts a message on the specified channel with a 100m range — five times the range of say.

// Announce an event across a wide area
this.shout(0, "The treasure hunt begins in 30 seconds!");

Broadcasts a message region-wide on a non-zero channel. Cannot be used on channel 0 to prevent spam.

// Broadcast a game state update to all listeners in the region
this.world.regionSay(100, JSON.stringify({ event: "round-start", round: 3 }));

Sends a message to a specific object or avatar by UUID, anywhere in the region.

// Send a direct message to a specific object
this.world.regionSayTo(targetId, 42, "ping");

Registers a listener for messages on a channel. Filter by sender name, UUID, or message content. Returns a handle for later removal.

// Listen for all messages on channel 42
const handle = this.listen(42, "", "", "");

// Listen for a specific command from anyone
const cmdHandle = this.listen(0, "", "", "open sesame");

Removes a previously registered listener. In poqpoq, call .remove() on the handle returned by listen().

const handle = this.listen(42, "", "", "");
// Later, stop listening
handle.remove();

Sends a private instant message to an avatar by UUID. The message appears in their IM window.

// Notify the owner when someone touches the object
this.world.instantMessage(this.owner.id, "Your object was touched!");

Sends a message visible only to the object's owner. Useful for debug output and owner-only notifications.

// Debug output only the owner sees
this.ownerSay("State changed to: " + currentState);

Sends a link message to other scripts in the same object. Used for inter-script communication within a linkset.

// Tell all scripts in this object to reset
this.sendLinkMessage(LINK_SET, 0, "reset", "");

// Send data to the root prim's scripts
this.sendLinkMessage(LINK_ROOT, 100, "update-score", "42");

Moves the object to the given position. Unlike LSL, there is no 0.2-second delay between moves.

// Move to a specific world coordinate
this.object.setPosition({ x: 128, y: 128, z: 25 });

// Move relative to current position
const pos = this.object.getPosition();
this.object.setPosition({ x: pos.x, y: pos.y, z: pos.z + 5 });

Returns the object's current position as a Vector3 ({ x, y, z }).

const pos = this.object.getPosition();
this.say(0, `I'm at <${pos.x}, ${pos.y}, ${pos.z}>`);

Sets the object's rotation using a quaternion ({ x, y, z, s }). Note the scalar is 's', following LSL's rotation type — NOT 'w' as in Babylon/three.js/glTF. A quaternion missing 's' is rejected loudly by the host rather than silently treated as identity.

// Rotate 90 degrees around the Z axis
const rot = Quaternion.fromEuler({ x: 0, y: 0, z: Math.PI / 2 });
this.object.setRotation(rot);

Returns the object's current rotation as a quaternion ({ x, y, z, s }). The scalar is 's' (LSL's spelling) — a script that reads the 'w' property instead gets undefined.

const rot = await this.object.getRotation();
this.say(0, `Facing: ${rot.s.toFixed(2)}`);

Sets the object's size. Each axis can be scaled independently.

// Make the object twice as tall
this.object.setScale({ x: 1, y: 1, z: 2 });

// Uniform scale to 50%
this.object.setScale({ x: 0.5, y: 0.5, z: 0.5 });

Returns the object's current size as a Vector3 ({ x, y, z }).

const size = this.object.getScale();
this.say(0, `Size: ${size.x} x ${size.y} x ${size.z}`);

Starts or stops another script in this object by its inventory name.

// Disable myself when preconditions fail
await this.script.setState(this.getScriptName(), false);

Returns how many texturable faces (sides) this prim has. Always at least 1.

// Cycle a texture across every face
integer sides = this.object.getNumberOfSides();
for (let i = 0; i < sides; i++) this.object.setAlpha(1.0, i);

Sets the color of one face or all faces of the object. Color is an RGB vector with values from 0 to 1.

// Make the whole object red
this.object.setColor({ x: 1, y: 0, z: 0 }, ALL_SIDES);

// Set just face 0 to blue
this.object.setColor({ x: 0, y: 0.4, z: 1 }, 0);

Sets the transparency of the object. 1.0 is fully opaque, 0.0 is fully invisible.

// Make the object semi-transparent
this.object.setAlpha(0.5, ALL_SIDES);

// Make it invisible
this.object.setAlpha(0.0, ALL_SIDES);

Returns a matching host inventory texture name, otherwise the stored UUID or native texture reference (including URLs). This is not full SL permission parity.

const texture = await this.object.getTexture(0);

Applies a texture to one or all faces of the object by asset name or UUID.

// Apply a texture to all faces
this.object.setTexture("wood-planks", ALL_SIDES);

// Apply to a specific face
this.object.setTexture("glass-panel", 2);

Displays floating text above the object. Set text to empty string to remove it.

// Show a label above the object
this.object.setText("Welcome!", { x: 0, y: 1, z: 0 }, 1.0);

// Remove floating text
this.object.setText("", { x: 0, y: 0, z: 0 }, 0);

Sets multiple visual properties of the object at once from LSL's flat PRIM_* rule list.

// Set face 0 red, then resize
llSetPrimitiveParams([PRIM_COLOR, 0, <1,0,0>, 1.0, PRIM_SIZE, <2,2,2>]);

Returns the name of the object this script is running in.

const name = this.object.name;
this.say(0, `I am ${name}`);

Returns the description string of the object.

const desc = this.object.description;
if (desc) this.say(0, desc);

Returns the UUID of the object this script is running in.

const myId = this.object.id;
this.say(0, `My UUID is ${myId}`);

Returns the UUID of the avatar who created this object.

const creator = this.object.creatorId;
this.say(0, `Created by ${creator}`);

Returns the UUID of the object's current owner.

const ownerId = this.owner.id;
this.world.instantMessage(ownerId, "Script initialized!");

Returns the number of prims (links) in the linkset, including seated avatars.

const count = await this.object.getLinkCount();
this.say(0, `This object has ${count} linked parts`);

Returns the UUID of a specific link (prim) in the linkset by link number.

const rootId = await this.object.getLinkKey(1);
this.say(0, `Root prim: ${rootId}`);

Returns the link number of the prim this script is running in (0=unlinked, 1=root, 2+=child).

const myLink = llGetLinkNumber();
if (myLink === 1) this.say(0, "I'm the root prim");

Returns the link number of the prim this script is running in.

Returns the name of a linked prim by link number.

const name = llGetLinkName(2);
this.say(0, "Child prim: " + name);

Sets visual and physical properties on a specific link in the linkset using the LSL PRIM_* rule list.

// Color link 2 red, link 3 blue
this.object.setLinkPrimitiveParams(2, [PRIM_COLOR, ALL_SIDES, [1, 0, 0], 1.0]);
this.object.setLinkPrimitiveParams(3, [PRIM_COLOR, ALL_SIDES, [0, 0, 1], 1.0]);

Reads visual and physical properties from a specific link using the LSL PRIM_* rule list.

// Read color and alpha from link 2, face 0
const result = await this.object.getLinkPrimitiveParams(2, [
  PRIM_COLOR, 0
]);

Sets the texture on a face of a linked prim. Use ALL_SIDES to apply to every face.

// Apply texture to face 0 of link 3
this.object.setLinkTexture(3, "texture-uuid", 0);

Sets the color of a face on one or more linked prims.

Sets the alpha of a face on one or more linked prims.

Returns the number of texturable faces on a linked prim.

Configures UV texture animation on a linked prim.

Configures atlas, scrolling, rotating, or scaling texture animation on the script host.

Sets the horizontal and vertical texture offset on one face or all faces.

Sets the horizontal and vertical texture repeats on one face or all faces.

Sets texture rotation in radians on one face or all faces.

Returns a face's texture offset as a vector.

Returns a face's texture repeats as a vector.

Returns a face's texture rotation in radians.

Returns TRUE when the named script in this object is running.

Resets a script in the same object by its inventory name.

Returns bytes remaining under the script memory limit. poqpoq does not yet define a compatible per-script memory model.

Returns the bytes currently reachable by one script on Second Life. poqpoq does not yet expose defensible per-script accounting.

integer used = llGetUsedMemory();
// poqpoq currently warns and returns 0; do not treat it as measured bytes.

Returns the script's configured memory limit in bytes.

Requests a script memory limit and reports whether the request succeeded.

Returns the script profiler's maximum recorded memory value.

Stops and restarts this script from its initial state.

Applies an instantaneous force impulse to a physical object. If local is true, force is relative to the object's rotation.

// Launch the object upward
this.object.applyImpulse({ x: 0, y: 0, z: 10 }, false);

// Push forward relative to the object's facing direction
this.object.applyImpulse({ x: 5, y: 0, z: 0 }, true);

Applies an instantaneous rotational impulse to a physical object, giving it a one-shot spin.

// Kick the object spinning around the Y axis
this.object.applyTorque({ x: 0, y: 5, z: 0 }, false);

Applies a continuous force to a physical object. The force persists until changed or set to zero.

// Apply a constant upward force (hover effect)
this.object.applyForce({ x: 0, y: 0, z: 9.8 }, false);
// Stop the force
this.object.applyForce({ x: 0, y: 0, z: 0 }, false);

Returns the object's current velocity as a Vector3. Useful for physics calculations and movement prediction.

const vel = await this.object.getVelocity();
const speed = Math.sqrt(vel.x ** 2 + vel.y ** 2 + vel.z ** 2);
this.say(0, `Speed: ${speed.toFixed(1)} m/s`);

Controls how gravity affects a physical object. In poqpoq, gravity is toggled on/off via physics config rather than a float buoyancy value.

// Make the object float (disable gravity)
this.object.setPhysics({ gravity: false });

Smoothly moves a physical object toward a target position over a duration. Uses animation options instead of LSL's tau parameter.

// Glide to a position over 2 seconds
this.object.setPosition({ x: 128, y: 128, z: 30 }, { duration: 2.0 });

Configures the physical material properties of the object such as friction, restitution (bounciness), and density.

// Make the object bouncy like a rubber ball
this.object.setPhysics({ restitution: 0.9, friction: 0.3 });

Returns the shortest rotation that carries one direction vector onto another.

const turn = Quaternion.between(from, to);

Smoothly rotates the object or canonical linkset frame toward an absolute rotation.

this.object.rotLookAt(targetRotation, 1.0, 0.4);

Stops an active positional or rotational look-at controller.

Returns the UUID of a detected agent or object from a sensor or touch event. In poqpoq, use array indexing on the detected parameter.

// In a touch_start handler
const toucherId = detected[0].id;
this.say(0, `Touched by ${toucherId}`);

Returns the name of a detected agent or object from a sensor or touch event.

const who = detected[0].name;
this.say(0, `Hello, ${who}!`);

Returns the position of a detected agent or object at the time of detection.

const pos = detected[0].position;
this.say(0, `They are at ${pos.x.toFixed(0)}, ${pos.y.toFixed(0)}`);

Returns the rotation of a detected agent or object at the time of detection.

const rot = detected[0].rotation;
// Use rotation to orient a response effect

Returns the velocity of a detected agent or object at the time of detection.

const vel = detected[0].velocity;
const isMoving = vel.x !== 0 || vel.y !== 0 || vel.z !== 0;

Returns the type of a detected entity (agent, active object, passive object, scripted, etc.).

const type = detected[0].type;
if (type === AGENT) this.say(0, "An avatar touched me!");

Returns the bounding box size of an avatar as a Vector3.

const size = await this.world.agent.getSize(id);
this.say(0, `Avatar height: ${size.z.toFixed(1)}m`);

Returns the public display name of an avatar or NPC present in the current sim.

Returns the name of the avatar, NPC, or object identified by a key, or an empty string when absent.

Returns the key of a currently present avatar or NPC with the given public name.

Returns the owner key of an in-region object.

Requests runtime permissions from an avatar (e.g., animation, camera control, payments). Triggers a run_time_permissions event when granted.

// Request permission to animate the toucher
this.requestPermissions(detected[0].id, PERMISSION_TRIGGER_ANIMATION);

Returns the key of the avatar whose permission grant this script currently holds, or NULL_KEY if none.

// A pose ball confirming the sitter actually granted
if (llGetPermissionsKey() == avatar && (llGetPermissions() & PERMISSION_TRIGGER_ANIMATION)) {
    llStartAnimation("sit_female");
}

Sets a sit target on the object, defining where and how an avatar sits on it.

// Set a sit position 0.5m above the object
this.object.setSitTarget(
  { x: 0, y: 0, z: 0.5 },
  { x: 0, y: 0, z: 0, s: 1 }  // scalar is 's', not 'w'
);

Attaches the object to the specified attachment point on the avatar who granted permissions.

// Attach to the right hand
this.world.attachToAvatar(ATTACH_RHAND);

Temporarily attaches the object to an avatar. The attachment is removed when the avatar logs out.

// Temporarily attach a party hat
this.world.attachToAvatarTemp(ATTACH_HEAD);

Detaches the object from the avatar it is currently attached to.

// Detach after use
this.say(0, "Removing attachment...");
this.world.detachFromAvatar();

Returns the attachment point the object is attached to, or 0 if not attached to any avatar.

const point = this.object.getAttached();
if (point > 0) this.say(0, "I am worn as an attachment");

Creates a particle emitter on the object. One entry point, two dialects: an ARRAY is the frozen LSL PSYS rule list (what transpiled LSL emits — bit-faithful, never extended); an OBJECT is a versioned poqpoq ParticleDescriptor exposing engine capability beyond LSL (multi-stop gradients, blend modes; Babylon Y-up frame, texture is URL-or-null). Pass an empty object {} to stop. See the Particles reference page for the descriptor contract.

// Open dialect: ember glow beyond LSL's two-point reach
// (multi-stop color gradient + additive blend)
this.object.particles({
  v: 1,
  texture: null, // procedural soft-dot; or a URL — no inventory names here
  blend: "add",
  capacity: 200,
  lifetime: { min: 1.0, max: 2.0 },
  color: [
    { t: 0.0, value: { r: 1.0, g: 0.9, b: 0.4, a: 0.0 } },
    { t: 0.2, value: { r: 1.0, g: 0.6, b: 0.1, a: 0.9 } },
    { t: 1.0, value: { r: 0.4, g: 0.05, b: 0.0, a: 0.0 } },
  ],
  colorDead: { r: 0, g: 0, b: 0, a: 0 },
  size: [ { t: 0, value: 0.12 }, { t: 1, value: 0.03 } ],
  burst: { rate: 0.1, count: 6 },
  emitPower: { min: 0.3, max: 0.8 },
  emitBox: null,
  direction: { min: { x: -0.2, y: 1, z: -0.2 }, max: { x: 0.2, y: 1, z: 0.2 } },
  gravity: null,
  duration: null,
});

// Stop particles
this.object.stopParticles();

Plays a sound once at the object's position. The sound is spatialized — it gets quieter with distance.

// Play a click sound
this.object.playSound("ui-click");

Plays a sound in a continuous loop at the specified volume (0.0 to 1.0).

// Ambient waterfall sound at 60% volume
this.object.loopSound("waterfall-ambient", 0.6);

Stops any currently playing or looping sound on the object.

// Stop the looping sound
this.object.stopSound();

Plays a sound at full volume regardless of distance. Unlike playSound, the sound is not spatialized, is not tracked, and cannot be stopped.

// Play a UI notification at full volume
this.object.triggerSound("notification", 1.0);

Preloads a sound from the object's inventory into the audio cache so a later llPlaySound starts without delay.

// Warm the click sound at state entry
this.object.preloadSound("ui-click");

Sets visual properties on a linked prim without the usual delay. In poqpoq, all property changes are instant.

// Change color of link 2
this.object.setLinkPrimitiveParams(2, [
  PRIM_COLOR, ALL_SIDES, [1, 0, 0], 1.0,
  PRIM_GLOW, ALL_SIDES, 0.2,
]);

Sets or stops a particle system on a linked prim.

Starts a repeating timer that fires the timer() event at the specified interval in seconds. Set to 0 to stop. poqpoq supports multiple named timers.

// Fire timer() every 2 seconds
this.setTimer(2.0);

// Stop the timer
this.setTimer(0);

Pauses the current script for the specified duration. Unlike LSL, this does NOT block other scripts — it uses async/await.

// Wait 3 seconds, then do something
await this.delay(3.0);
this.say(0, "Done waiting!");

Performs a one-shot scan for objects or avatars within range and arc. Triggers sensor() or no_sensor() event.

// Scan for avatars within 20m, 90-degree arc
this.sensor("", "", AGENT, 20.0, Math.PI / 2);

Starts a repeating sensor scan at the specified rate (in seconds). Triggers sensor() or no_sensor() on each scan.

// Scan for nearby avatars every 5 seconds within 30m
this.sensorRepeat("", "", AGENT, 30.0, Math.PI, 5.0);

Stops the currently active repeating sensor scan started by sensorRepeat().

// Stop scanning for avatars
this.sensorRemove();

Casts a ray between two points and returns information about what it hits. Useful for line-of-sight checks and targeting.

// Check if there's a clear line of sight
const hits = await this.world.raycast(
  this.object.getPosition(),
  targetPos,
  { detectPhysical: true, maxHits: 1 }
);

Returns the number of avatars currently present in the sim.

const count = await this.world.sim.getAgentCount();
this.say(0, `There are ${count} visitors here.`);

Returns a list of avatar UUIDs in the requested scope.

const agents = await this.world.sim.getAgents(AGENT_LIST_REGION, []);
for (const id of agents) { this.world.instantMessage(id, "hi"); }

Returns the name of the sim the object is currently in.

const sim = await this.world.sim.getName();
this.say(0, `Welcome to ${sim}!`);

Reads a single 0-indexed line from a notecard in the object's inventory. In LSL this returns a dataserver query key and the line arrives in the dataserver event; TS-authored scripts can await the line text directly.

// Read the first line of a config notecard
const line = await this.world.getNotecardLine("config", 0);
this.say(0, line);

Makes an HTTP request to an external URL. Returns the response directly via await — no callback event needed.

// Fetch data from an API
const response = await this.world.http.get("https://api.example.com/scores");
this.say(0, `High score: ${response}`);

Returns the number of lines in a notecard stored in the object's inventory. Uses async/await instead of the LSL dataserver callback.

const lineCount = await this.world.getNumberOfNotecardLines("config");
this.say(0, `Config has ${lineCount} lines`);

Calculates the Euclidean distance between two vectors.

const dist = myPos.distanceTo(targetPos);
if (dist < 10) this.say(0, "Target is nearby!");

Returns a unit vector (length 1) pointing in the same direction as the input vector.

const direction = offset.normalize();
// Move 5 meters in that direction
const step = { x: direction.x * 5, y: direction.y * 5, z: direction.z * 5 };

Returns the magnitude (length) of a vector. Useful for calculating speed or distance from origin.

const speed = velocity.length();
this.say(0, `Moving at ${speed.toFixed(1)} m/s`);

Converts a quaternion rotation to Euler angles (radians) as a Vector3.

const euler = this.object.getRotation().toEuler();
this.say(0, `Heading: ${(euler.z * 180 / Math.PI).toFixed(0)} degrees`);

Converts Euler angles (radians) to a quaternion rotation.

// Create a 45-degree rotation around the Z axis
const rot = Quaternion.fromEuler({ x: 0, y: 0, z: Math.PI / 4 });

Returns the object's local up axis after applying a rotation.

Returns the object's local forward axis after applying a rotation.

Returns the object's local left axis after applying a rotation.

Creates a quaternion rotation from an axis vector and angle in radians.

// Rotate 90 degrees around the Y axis
const rot = Quaternion.fromAxisAngle({ x: 0, y: 1, z: 0 }, Math.PI / 2);

Returns a random floating-point number between 0 and the given maximum.

// Random delay between 1 and 5 seconds
const delay = 1 + Math.random() * 4;
await this.delay(delay);

Returns the absolute (non-negative) value of an integer.

const distance = Math.abs(posA.x - posB.x);

Returns the absolute (non-negative) value of a float.

const drift = Math.abs(current - target);

Rounds a float down to the nearest integer.

const gridX = Math.floor(pos.x / 4);
const gridY = Math.floor(pos.y / 4);

Rounds a float up to the nearest integer.

const pagesNeeded = Math.ceil(totalItems / itemsPerPage);

Rounds a float to the nearest integer.

const rounded = Math.round(score * 100) / 100;
this.say(0, `Score: ${rounded}`);

Returns the square root of a number.

const hypotenuse = Math.sqrt(dx * dx + dy * dy);

Returns base raised to exponent, modulo modulus, interpreting all three inputs as unsigned 32-bit values and returning the signed 32-bit result.

default {
    touch_start(integer count) {
        llOwnerSay("Modular power: " + (string)llModPow(13743, 14200, 10000));
    }
}

Returns the natural logarithm. Nonpositive inputs return zero.

default {
    touch_start(integer count) {
        llOwnerSay("Natural log of 2: " + (string)llLog(2.0));
    }
}

Returns the base-ten logarithm. Nonpositive inputs return zero.

default {
    touch_start(integer count) {
        llOwnerSay("Base-ten log of 100: " + (string)llLog10(100.0));
    }
}

Returns the base raised to the exponent power.

// Exponential falloff for damage over distance
const falloff = Math.pow(0.5, dist / 10);

Returns the sine of an angle in radians.

// Bobbing motion using sine wave
const z = baseZ + Math.sin(time * 2) * 0.5;

Returns the cosine of an angle in radians.

// Circular orbit path
const x = center.x + Math.cos(angle) * radius;
const y = center.y + Math.sin(angle) * radius;

Returns the tangent of an angle in radians.

const slope = Math.tan(angle);

Returns the arcsine (inverse sine) of a value, in radians.

const angle = Math.asin(opposite / hypotenuse);

Returns the arccosine (inverse cosine) of a value, in radians.

// Calculate angle between two normalized vectors via dot product
const angle = Math.acos(dot);

Returns the angle in radians between the positive X axis and the point (x, y). Handles all four quadrants correctly.

// Calculate heading angle to a target
const dx = target.x - myPos.x;
const dy = target.y - myPos.y;
const heading = Math.atan2(dy, dx);

Generates a new non-null UUID that can be used as an identifier.

default {
    touch_start(integer count) {
        // Touch your scripted box to print a new identifier.
        key identifier = llGenerateKey();
        llOwnerSay((string)identifier);
    }
}

Creates a string from a Unicode code point, including supplementary characters such as emoji.

default {
    state_entry() {
        llOwnerSay("Status: " + llChar(9733) + " " + llChar(128512));
    }
}

Replaces literal substrings: positive counts search from the left, negative counts from the right, and zero replaces all matches.

default {
    state_entry() {
        string message = "red foxes, red hens, red turnips";
        llOwnerSay(llReplaceSubString(message, "red", "green", -1));
    }
}

Returns the number of characters in a string.

const len = message.length;
if (len > 255) this.say(0, "Message too long!");

Returns the index of the first occurrence of a substring, or -1 if not found.

const idx = message.indexOf("password");
if (idx !== -1) this.say(0, "Keyword detected!");

Extracts a portion of a string between the start and end indices.

const prefix = command.substring(0, 3);
if (prefix === "cmd") this.say(0, "Command received");

Removes a substring between the given indices from a string and returns the result.

// Remove characters 3-5 from a string
const cleaned = text.slice(0, 3) + text.slice(6);

Converts all characters in a string to lowercase.

const cmd = message.toLowerCase();
if (cmd === "help") this.say(0, "Available commands: help, reset");

Converts all characters in a string to uppercase.

const shout = name.toUpperCase();
this.say(0, `ANNOUNCING: ${shout}`);

Encodes a string as Base64.

Computes a signed 32-bit SDBM hash over Unicode characters; empty text returns zero.

default {
    touch_start(integer count) {
        llOwnerSay("Name hash: " + (string)llHash(llGetObjectName()));
    }
}

Decodes Base64 into a UTF-8 string.

Encodes an LSL signed 32-bit integer in its eight-character Base64 representation.

Decodes an LSL Base64 integer.

Percent-encodes UTF-8 bytes using the RFC 3986 unreserved set.

Decodes percent-escaped UTF-8 sequences.

Returns the LSL nonce-composed MD5 digest.

Returns the lowercase SHA-1 digest of a string's UTF-8 bytes.

Splits a string into an array using the specified separator.

const parts = message.split("|");
const command = parts[0];
const data = parts[1];

Removes leading and trailing whitespace from a string.

const cleaned = input.trim();
if (cleaned.length > 0) this.say(0, cleaned);

Returns the number of elements in an array.

const count = inventory.length;
this.say(0, `You have ${count} items`);

Returns the element at the given index as a string. In TypeScript, simply access the array by index.

const names = ["Alice", "Bob", "Charlie"];
const first = names[0]; // "Alice"

Returns the element at the given index as an integer. In TypeScript, array access returns the typed value directly.

const scores = [100, 250, 50];
const topScore = scores[1]; // 250

Returns the TYPE_* constant for a list entry.

Returns the element at the given index as a float. TypeScript numbers handle both integer and float values.

const heights = [1.5, 2.0, 0.8];
const tallest = heights[1]; // 2.0

Returns the vector at the given list index, or ZERO_VECTOR when the entry is absent or has another type.

Returns the rotation at the given list index, or ZERO_ROTATION when the entry is absent or has another type.

Sorts the array in place. Accepts an optional comparator function for custom sort order.

const scores = [30, 10, 50, 20];
scores.sort((a, b) => b - a); // [50, 30, 20, 10]

Returns a new list containing existing elements in the requested range, preserving their values.

default
{
    state_entry()
    {
        list values = [1,2,3,4];
        llOwnerSay("[" + llDumpList2String(llList2List(values,-5,-5),",") + "]"); // []
        llOwnerSay("[" + llDumpList2String(llList2List(values,3,1),",") + "]"); // [1,2,4]
    }
}

Selects a strided inclusive range from a list.

Returns one column from each stride within an inclusive or exclusion list range, preserving element values.

Returns a randomized copy of a list while preserving stride groups.

Computes a selected statistic over numeric list entries.

Returns the first index of a matching list subsequence, or -1 if not found.

// Original LSL: search for a contiguous two-item sequence.
default
{
    state_entry()
    {
        list values = ["start", <1,2,3>, "ready", <4,5,6>];
        integer index = llListFindList(values, [<1,2,3>, "ready"]);
        llOwnerSay((string)index); // 1
    }
}

Converts an array to a comma-separated string.

const tags = ["red", "large", "sale"];
const csv = tags.join(","); // "red,large,sale"

Parses LSL CSV into strings, preserving bracketed commas and empty fields; removes one leading space per field. Helper emitted by the LSL transpiler.

// LSL: llCSV2List("name, <1,2,3>,")
// Result: ["name", "<1,2,3>", ""]

Inserts elements into an array at the specified position without removing existing elements.

const queue = ["A", "C", "D"];
queue.splice(1, 0, "B"); // ["A", "B", "C", "D"]

Removes elements from an array starting at the given index for the specified count.

const items = ["sword", "shield", "potion", "scroll"];
items.splice(1, 2); // removes "shield" and "potion"

Returns a copy of dest with the inclusive range [start..end] replaced by the contents of src. An empty src deletes the range.

const inventory = ["sword", "shield", "potion"];
// replace slot 1 with two items
const updated = lslListReplaceList(inventory, ["helm", "cloak"], 1, 1);

Returns the current in-world time of day as seconds since midnight.

const seconds = await this.world.environment.getTimeOfDay();
const hours = Math.floor(seconds / 3600);
this.say(0, `It is ${hours}:00 in-world time`);

Returns a normalized Vector3 pointing toward the sun. Useful for lighting effects and shadow calculations.

const sunDir = await this.world.environment.getSunDirection();
const isNight = sunDir.z < 0;

Sets the sun direction for the active sim, as a normalized direction vector. Controls sky lighting and shadow angle.

// Point the sun low on the horizon
this.world.environment.setSunDirection(new Vector3(1, 0, 0.1));

Sets the streaming music URL for the sim. Every visitor hears the stream; an empty URL stops it.

// Start the venue stream
this.world.environment.setParcelMusicURL("https://stream.example.com/dj-set");

// Stop the music
this.world.environment.setParcelMusicURL("");

Returns the current Unix timestamp (seconds since January 1, 1970).

const now = llGetUnixTime();
const elapsed = now - startTime;
this.say(0, `Elapsed: ${elapsed} seconds`);

Returns seconds elapsed on this script's local clock.

Resets this script's elapsed-time clock to zero.

Returns elapsed script time and then resets the clock to zero.

Returns the current UTC date as a string in YYYY-MM-DD format.

const today = llGetDate();
this.say(0, `Daily reset for ${today}`);

Returns the number of seconds since midnight UTC, as a float.

const secondsToday = llGetGMTclock();
const isMorningUTC = secondsToday < 12 * 3600;

Returns the current UTC date and time as YYYY-MM-DDThh:mm:ss.ffffffZ.

const stamp = llGetTimestamp();
this.say(0, `Logged at ${stamp}`);

Returns the terrain height at a given position. Useful for placing objects on the ground.

const pos = await this.object.getPosition();
const groundZ = await this.world.getGroundHeight(pos);
this.say(0, `Height above ground: ${(pos.z - groundZ).toFixed(1)}m`);

Creates an NPC using the legacy first-name, last-name and appearance-source contract. Returns a UUID string, or NULL_KEY when unsupported or creation fails. World resolves the appearance source through its configured GLB model mapping; clothing and shape cards are not reconstructed. Explicit flags require host support.

// Host maps npc_appearance to a GLB model
const npcId = await this.world.npc.createLegacy(
  "Merchant",
  "Bob",
  { x: 128, y: 128, z: 25 },
  "npc_appearance"
);
if (npcId !== "00000000-0000-0000-0000-000000000000") {
  await this.world.npc.say(npcId, "Welcome!");
  // Later: await this.world.npc.remove(npcId);
}

Removes the NPC identified by the UUID returned by createLegacy.

await this.world.npc.remove(npcId);

Requests movement for the NPC UUID. The Promise acknowledges the host command; it does not promise arrival.

await this.world.npc.moveTo(npcId, { x: 130, y: 128, z: 25 });

Makes the NPC UUID speak on the specified channel.

await this.world.npc.say(npcId, "Welcome!", 0);

Commands an NPC to sit on a target object (chair, bench, vehicle).

await this.world.npc.sit(npcId, benchId);

Commands a seated NPC to stand up.

await this.world.npc.stand(npcId);
await this.world.npc.moveTo(npcId, new Vector3(130, 128, 25));

Requests a named animation on the NPC UUID.

await this.world.npc.playAnimation(npcId, "wave");

Stops the named animation on the NPC UUID.

await this.world.npc.stopAnimation(npcId, "wave");

Sets the NPC's facing rotation.

await this.world.npc.setRotation(npcId, new Quaternion(0, 0.707, 0, 0.707));

Counts lines in a named notecard in this object's Contents. Unlike the ll variant, this returns the count directly.

const count = await this.world.getNotecardLineCountDirect("actionCard");
if (count < 0) this.say(0, "Route card unavailable");

Reads the entire contents of a named notecard from the object's inventory as a single string.

const config = await this.world.getNotecard("settings");
this.say(0, "Config: " + config);

Parses a JSON string into a JavaScript object. Maps directly to native JSON.parse().

const data = JSON.parse(jsonStr);
this.say(0, "Name: " + data.name);

Modifies terrain height at a position. Requires elevated permissions (Tier 3).

// Raise terrain at position
this.world.environment.setTerrainTexture(
  { x: 128, y: 128, z: 0 }, "grass", 5
);

Returns the dominant ground texture ID at a world position.

const tex = this.world.getGroundTexture({ x: 128, y: 128, z: 0 });
this.say(0, "Ground: " + tex);

Paints a terrain texture at a position with a given radius. Requires Tier 3 permission.

// Paint sand texture in a 10m radius
this.world.environment.setTerrainTexture(
  { x: 128, y: 128, z: 0 }, "sand", 10
);

Teleports an avatar to a destination sim and position. Requires permission from the agent.

// Teleport the toucher to the spawn point of another sim
await osTeleportAgent(id, "Welcome", new Vector3(128, 128, 25), ZERO_VECTOR);

Returns the key for a currently present avatar or NPC public name.

Returns TRUE when the key identifies a currently present NPC.

Returns public names for agents in the active sim.

Returns an empty string under poqpoq's privacy profile.

default {
    state_entry() {
        // Never print or store an address. Only verify the restricted result.
        string value = osGetAgentIP((string)llGetOwner());
        if (value == "") llOwnerSay("osGetAgentIP: restricted");
        else llOwnerSay("osGetAgentIP: unexpected nonempty result");
    }
}

Sets a prim face texture from a URL. Partially supported — UUID-based textures are not resolved.

// Apply a web-hosted texture
this.object.setTexture("https://example.com/logo.png", 0);

Configures a media surface (web page, video, etc.) on a prim face using PRIM_MEDIA_* rule constants.

// Display a web page on face 0
this.object.setMediaParams(0, [
  PRIM_MEDIA_CURRENT_URL, "https://poqpoq.com",
  PRIM_MEDIA_AUTO_PLAY, true
]);

Removes the media surface from a prim face, stopping any playing media.

// Remove media from face 0
this.object.clearMedia(0);

Retrieves current media parameter values for a prim face. Returns a list of values matching the requested PRIM_MEDIA_* keys.

// Get the current URL on face 0
const params = this.object.getMediaParams(0, [PRIM_MEDIA_CURRENT_URL]);
this.say(0, "Playing: " + params[0]);

Configures a media surface on a face of a linked prim.

// Set video on face 1 of link 3
this.object.setLinkMediaParams(3, 1, [
  PRIM_MEDIA_CURRENT_URL, "https://example.com/video"
]);

Removes the media surface from a face on a linked prim.

// Clear media from face 0 of link 2
this.object.clearLinkMedia(2, 0);

Retrieves media parameter values from a face on a linked prim.

// Check what URL is playing on link 3, face 0
const params = await this.object.getLinkMediaParams(3, 0, [PRIM_MEDIA_CURRENT_URL]);

Shows a dialog box to an avatar with up to 12 buttons. The avatar's button choice is sent as a chat message on the specified channel.

// Ask the user to pick a color
this.world.dialog(
  detected[0].id,
  "Choose your team color:",
  ["Red", "Blue", "Green"],
  42
);
// Listen for the response
this.listen(42, "", detected[0].id, "");

Shows a text input box to an avatar. The typed text is sent as a chat message on the specified channel.

// Ask for the player's name
this.world.textBox(detected[0].id, "Enter your character name:", 42);

Opens a dialog asking the avatar to visit an external URL. The avatar must confirm before the browser opens.

// Offer a link to documentation
this.world.loadURL(detected[0].id, "View the wiki?", "https://wiki.poqpoq.com");

Opens the world map centered on a specific region and location, allowing the avatar to teleport there.

// Show the map pointing to a destination
this.world.mapDestination("Welcome Plaza", { x: 128, y: 128, z: 25 }, { x: 128, y: 129, z: 25 });

Returns the number of inventory items of a given type (scripts, textures, sounds, etc.) in the object.

const scriptCount = this.container.getAssetCount(INVENTORY_SCRIPT);
this.say(0, `Contains ${scriptCount} scripts`);

Returns the name of an inventory item by type and index. Useful for iterating over all items of a given type.

// List all textures in the object
const count = this.container.getAssetCount(INVENTORY_TEXTURE);
for (let i = 0; i < count; i++) {
  this.say(0, this.container.getAssetName(INVENTORY_TEXTURE, i));
}

Returns the type constant for a named inventory item, or -1 if not found.

const type = this.container.getAssetType("my-asset");
if (type === INVENTORY_SOUND) {
  this.object.playSound("my-asset");
}

Returns the UUID of a named inventory item, or undefined if not found.

const texId = this.container.getAsset("logo")?.id;
if (texId) this.object.setTexture(texId, 0);

Returns the UUID of the creator of a named inventory item.

const creator = this.container.getAssetCreator("my-script");
this.say(0, "Script created by: " + creator);

Returns the permission bitmask for a named inventory item. Check against PERM_COPY, PERM_MODIFY, PERM_TRANSFER constants.

const perms = this.container.getAssetPermMask("gadget", MASK_OWNER);
const canCopy = (perms & PERM_COPY) !== 0;

Enables or disables dropping inventory items into this object, even without modify permissions.

// Allow anyone to drop items into this object
this.object.allowInventoryDrop(true);

Gives a named inventory item from this object to a destination avatar or object by UUID.

// Give a notecard to whoever touched the object
this.world.giveInventory(detected[0].id, "Welcome Guide");

Gives multiple inventory items bundled into a named folder to a destination avatar.

// Give a starter kit to a new visitor
this.world.giveInventoryList(
  detected[0].id,
  "Starter Kit",
  ["Map", "Compass", "Guide"]
);

Removes a named item from the object's inventory. Use with caution as this is irreversible.

// Remove a used single-use item
this.container.removeAsset("one-time-pass");

Gives money from the object owner's account to the specified avatar or object.

// Pay the player 50 coins for completing a quest
this.world.giveMoney(detected[0].id, 50);

Transfers currency to another avatar asynchronously. Returns a transaction key and triggers a transaction_result event on completion.

const txnId = await this.world.transferLindenDollars(buyerId, 100);
this.say(0, `Transaction ${txnId} initiated`);

Configures the pay dialog that appears when an avatar right-clicks the object and selects Pay. Sets a default amount and up to four quick-pay buttons.

// Set default to 10, with quick buttons for 5, 10, 25, 50
this.world.setPayPrice(10, [5, 10, 25, 50]);

Returns the object owner's current currency balance.

const balance = this.world.getBalance();
this.say(0, `Your balance: ${balance} coins`);

Inflicts damage on an NPC. Returns true if the NPC was alive before the hit. Optionally identifies the damage source.

const wasAlive = this.world.npc.damage(npcId, 25, this.object.id);
if (!wasAlive) this.say(0, "Target already defeated!");

Returns true if the NPC is flagged as hostile toward players.

if (this.world.npc.isHostile(npcId)) {
  this.say(0, "Warning: hostile NPC detected!");
}

Sets or clears the hostility flag on an NPC, changing how it interacts with players and other NPCs.

// Make the guard hostile when provoked
this.world.npc.setHostile(guardId, true);

Finds the nearest valid NPC target from a world position within an optional range. Returns target info or null if none found.

const target = this.world.npc.getNearestTarget(myPos, 20);
if (target) {
  this.say(0, `Nearest enemy: ${target.name} at ${target.distance}m`);
}

Returns an array of all NPC targets within the specified radius from a world position.

const enemies = this.world.npc.getTargetsInRadius(myPos, 30);
this.say(0, `${enemies.length} enemies nearby`);

Respawns a defeated NPC at its original spawn point or at an optional new position with full health.

// Respawn after a delay
await this.delay(10);
this.world.npc.respawn(npcId);

Assigns one or more autonomous steering behaviors to an NPC. Behaviors are blended together each frame for natural movement.

// Patrol NPC that wanders but stays near home
this.world.npc.setSteering(guardId, [
  { type: "wander", weight: 1.0 },
  { type: "tether", target: spawnPos, radius: 15, weight: 2.0 }
], 3.0);

Removes all active steering behaviors from an NPC, stopping autonomous movement.

// Stop the NPC when the player interacts
this.world.npc.clearSteering(npcId);
npc.say("You wanted to talk?", 0);

Returns the current world-space position of an NPC, or null if the NPC doesn't exist.

const pos = this.world.npc.getPosition(npcId);
if (pos) this.say(0, `NPC is at ${pos.x}, ${pos.y}, ${pos.z}`);

Returns the current rotation quaternion of an NPC, or null if the NPC doesn't exist.

const rot = this.world.npc.getRotation(npcId);
if (rot) this.say(0, "NPC facing: " + JSON.stringify(rot));

Equips the current object to a named attachment slot on the avatar. Uses the 25-slot attachment system.

// Equip a sword to the right hand
this.world.avatar.equip("right_hand");

Removes whatever item is equipped in the named attachment slot.

// Unequip the helmet
this.world.avatar.unequip("head");

Toggles visibility of an attachment slot without actually equipping or removing the item. Useful for costume changes.

// Hide the cape during combat
this.world.avatar.setAttachmentVisible("spine", false);

Returns detailed info about an attachment slot: its ID, label, whether it has an item, the item's ID, and visibility state.

const slot = this.world.avatar.getAttachment("right_hand");
if (slot.hasItem) this.say(0, "Wielding: " + slot.itemId);

Returns an array of all 25 attachment slots with their current state (equipped items, visibility, labels).

const slots = this.world.avatar.getAttachmentPoints();
const equipped = slots.filter(s => s.hasItem);
this.say(0, `${equipped.length} items equipped`);

Adjusts the position offset, rotation, and scale of an item in an attachment slot for precise fitting.

// Nudge the hat forward and scale it up slightly
this.world.avatar.adjustAttachment("head",
  { x: 0, y: 0.05, z: 0 },
  undefined,
  { x: 1.1, y: 1.1, z: 1.1 }
);

Applies a continuous force vector to the object each physics frame. Use local=true for object-relative direction.

// Thrust forward in local space
this.object.applyForce({ x: 0, y: 0, z: 10 }, true);

Applies a one-time impulse force to the object. Unlike applyForce, this fires once and doesn't persist.

// Launch the ball upward
this.object.applyImpulse({ x: 0, y: 15, z: 0 });

Applies continuous rotational torque to the object around the specified axes.

// Spin the object around its Y axis
this.object.setTorque({ x: 0, y: 5, z: 0 }, true);

Pushes another object by ID with both linear and angular impulse. Useful for explosions and knockback effects.

// Knockback an enemy object
this.world.pushObject(enemyId,
  { x: 0, y: 5, z: -10 },
  { x: 2, y: 0, z: 0 }
);

Sets physics status flags on the object (STATUS_PHYSICS, STATUS_PHANTOM, STATUS_ROTATE_X/Y/Z, etc.).

// Make the object physical
this.object.setStatus(STATUS_PHYSICS, true);

Sets the amount of damage this object deals on collision with other objects or avatars.

// Projectile deals 50 damage on impact
this.object.setDamage(50);

Enables volume detection mode — the object detects collisions and fires events but doesn't physically block other objects.

// Trigger zone: detect entry without blocking
this.object.volumeDetect(true);

Configures collision filtering by object name or ID pattern. Accept=true whitelists, accept=false blacklists.

// Only collide with objects named "ball"
this.object.collisionFilter("ball", "", true);

Sets the buoyancy factor. 0 = full gravity, 1 = weightless/neutral, values above 1 cause the object to float upward.

// Make a balloon that floats gently
this.object.setBuoyancy(1.3);

Cancels an active moveToTarget operation, stopping the object at its current position.

// Abort the movement
this.object.stopMoveToTarget();
this.say(0, "Movement cancelled");

Makes the object continuously face a target position with configurable strength and damping for smooth rotation.

// Turret tracks the player
this.object.lookAt(playerPos, 3.0, 0.8);

Cancels an active lookAt constraint, freeing the object to rotate normally.

this.object.stopLookAt();

Overrides the physics collision shape used for this object. Supports box, sphere, capsule, convex hull, and triangle mesh.

// Use a sphere collider for a ball object
this.object.setPhysicsShape("sphere", { radius: 0.5 });

Registers this object as a terrain influence source that dynamically blends textures in its vicinity based on radius and falloff.

// Campfire scorches the ground around it
this.object.setTerrainInfluence({
  radius: 3, falloff: "linear",
  texture: "scorched_earth", blendMode: "overlay"
});

Returns the current terrain influence configuration for this object, or null if none is registered.

const influence = this.object.getTerrainInfluence();
if (influence) this.say(0, "Radius: " + influence.radius);

Removes this object's terrain influence, restoring the ground beneath it to its natural texture.

// Clean up when the campfire is extinguished
this.object.clearTerrainInfluence();

Returns the dominant ground texture ID at a world position. Useful for footstep sounds or movement speed modifiers.

const ground = this.world.getGroundTexture(this.object.getPosition());
if (ground === "sand") this.say(0, "Walking on sand...");

Returns all active terrain influence sources near a position within an optional radius.

const influences = this.world.getTerrainInfluences(myPos, 20);
this.say(0, `${influences.length} terrain effects nearby`);

Returns recent terrain modification events (footprints, scorches, impacts) within a radius, optionally filtered by age.

// Check for recent footprints (tracking system)
const tracks = this.world.getTerrainEvents(myPos, 10, 60);
if (tracks.length > 0) this.say(0, "Fresh tracks found!");

Permanently paints a terrain texture at a world position with a given radius. Requires Tier 3 elevated permissions.

// Paint a grass path
this.world.environment.setTerrainTexture(
  { x: 128, y: 128, z: 0 }, "grass_path", 2, 0.8
);

Applies a temporary visual terrain effect with a time-to-live. Effects fade naturally without permanent terrain changes.

// Scorch mark from an explosion (fades in 30s)
this.world.environment.applyTerrainEffect(
  impactPos, { type: "scorch", radius: 2, ttl: 30 }
);

Triggers a named VFX archetype at a world position. The archetype defines particles, shaders, and timing. Luminary integration pending.

// Fire a healing burst VFX at the player
this.world.vfx.trigger("heal_burst",
  playerPos, { paletteSource: "caster" }
);

Retrieves a read-only VFX palette snapshot containing soul color, particle style, emissive boost, and other visual identity data.

const palette = this.world.vfx.getPalette("player");
this.say(0, "Soul color: " + JSON.stringify(palette.soulColor));

Registers a custom VFX archetype in the user namespace. Archetypes define particle systems, timing, and visual parameters for reuse.

// Register a custom sparkle effect
this.world.vfx.registerArchetype("user:sparkle", {
  particles: { pattern: "explode", color: { x: 1, y: 0.8, z: 0 } },
  duration: 2.0
});

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.

This function has a compiler handler but no curated catalog entry. Recognition does not establish full behavioral parity.