@driftengine/script 4.7.0 → 4.7.1

package/capabilities.json

@@ -1034,6 +1034,93 @@
       "doc": "Where something sits in the stereo field, relative to a listener facing yaw.",
       "implementation": "audio.stereoPan"
     },
+    {
+      "module": "drift/audio",
+      "name": "duck",
+      "signature": "fn(bus: String, factor: f32, seconds: f32) -> bool",
+      "params": [
+        {
+          "name": "bus",
+          "type": "String"
+        },
+        {
+          "name": "factor",
+          "type": "f32"
+        },
+        {
+          "name": "seconds",
+          "type": "f32"
+        }
+      ],
+      "returns": "bool",
+      "effects": [
+        "audio.write"
+      ],
+      "deterministic": false,
+      "doc": "Take a bus down to factor of its fader over seconds, 1 to bring it back, leaving the fader where the player set it. False when the mix has no bus of that name.",
+      "implementation": "MixBus.duck"
+    },
+    {
+      "module": "drift/audio",
+      "name": "fade",
+      "signature": "fn(bus: String, level: f32, seconds: f32) -> bool",
+      "params": [
+        {
+          "name": "bus",
+          "type": "String"
+        },
+        {
+          "name": "level",
+          "type": "f32"
+        },
+        {
+          "name": "seconds",
+          "type": "f32"
+        }
+      ],
+      "returns": "bool",
+      "effects": [
+        "audio.write"
+      ],
+      "deterministic": false,
+      "doc": "Move a bus's fader to level over seconds. For a bus the game made: the music and effects faders are the player's, and duck is how a script goes over them. False when the mix has no bus of that name.",
+      "implementation": "MixBus.fadeLevel"
+    },
+    {
+      "module": "drift/audio",
+      "name": "recall",
+      "signature": "fn(snapshot: String, seconds: f32) -> bool",
+      "params": [
+        {
+          "name": "snapshot",
+          "type": "String"
+        },
+        {
+          "name": "seconds",
+          "type": "f32"
+        }
+      ],
+      "returns": "bool",
+      "effects": [
+        "audio.write"
+      ],
+      "deterministic": false,
+      "doc": "Crossfade every level, mute and send to a snapshot the host captured, over seconds. False when nothing was captured under that name.",
+      "implementation": "MixConsole.recall"
+    },
+    {
+      "module": "drift/audio",
+      "name": "pulse",
+      "signature": "fn() -> f32",
+      "params": [],
+      "returns": "f32",
+      "effects": [
+        "nondeterministic"
+      ],
+      "deterministic": false,
+      "doc": "How hard the music is kicking, 0 to 1, spiking on each kick and falling back. 0 when the host runs no kick detector.",
+      "implementation": "KickDetector.pulse"
+    },
     {
       "module": "drift/behavior",
       "name": "tick",
@@ -1552,6 +1639,28 @@
       "doc": "kg of liquid water on the surface, per square metre of it.",
       "implementation": "drift/chemistry.wetness"
     },
+    {
+      "module": "drift/chemistry",
+      "name": "wettable",
+      "signature": "fn(chem: Chemistry, parcel: i32) -> bool",
+      "params": [
+        {
+          "name": "chem",
+          "type": "Chemistry"
+        },
+        {
+          "name": "parcel",
+          "type": "i32"
+        }
+      ],
+      "returns": "bool",
+      "effects": [
+        "chemistry.read"
+      ],
+      "deterministic": true,
+      "doc": "Whether this material can hold liquid water, which is what `wet` asks. Rain over everything asks first, since `wet` refuses an iron nail.",
+      "implementation": "drift/chemistry.wettable"
+    },
     {
       "module": "drift/chemistry",
       "name": "phase",
@@ -2838,6 +2947,28 @@
       "doc": "The entity the last `findNearest` on this world found. **Valid only until the next one**, and meaningless when that answered false — the same lifetime a raycast hit has.",
       "implementation": "drift/ecs.nearest"
     },
+    {
+      "module": "drift/ecs",
+      "name": "instantiate",
+      "signature": "fn(world: World, prefab: String) -> Entity",
+      "params": [
+        {
+          "name": "world",
+          "type": "World"
+        },
+        {
+          "name": "prefab",
+          "type": "String"
+        }
+      ],
+      "returns": "Entity",
+      "effects": [
+        "ecs.write"
+      ],
+      "deterministic": false,
+      "doc": "Make an entity from a prefab, with every component it names. Overrides are the host’s to apply; a script that wants a different value writes it after.",
+      "implementation": "drift/ecs.instantiate"
+    },
     {
       "module": "drift/editor",
       "name": "translateMode",
@@ -4326,6 +4457,96 @@
       "doc": "Stop whatever that pad is playing. Answers whether the platform took it.",
       "implementation": "drift/input.stopRumble"
     },
+    {
+      "module": "drift/input",
+      "name": "touchX",
+      "signature": "fn(touch: Touch) -> f32",
+      "params": [
+        {
+          "name": "touch",
+          "type": "Touch"
+        }
+      ],
+      "returns": "f32",
+      "effects": [
+        "input.read"
+      ],
+      "deterministic": false,
+      "doc": "The touch stick's horizontal, -1 to 1, 0 while no thumb is on it.",
+      "implementation": "drift/input.touchX"
+    },
+    {
+      "module": "drift/input",
+      "name": "touchY",
+      "signature": "fn(touch: Touch) -> f32",
+      "params": [
+        {
+          "name": "touch",
+          "type": "Touch"
+        }
+      ],
+      "returns": "f32",
+      "effects": [
+        "input.read"
+      ],
+      "deterministic": false,
+      "doc": "The touch stick's vertical, -1 to 1, up negative as a gamepad stick's is.",
+      "implementation": "drift/input.touchY"
+    },
+    {
+      "module": "drift/input",
+      "name": "touchHeld",
+      "signature": "fn(touch: Touch) -> bool",
+      "params": [
+        {
+          "name": "touch",
+          "type": "Touch"
+        }
+      ],
+      "returns": "bool",
+      "effects": [
+        "input.read"
+      ],
+      "deterministic": false,
+      "doc": "Whether a thumb is held still on the action side of the screen: the held form of the primary.",
+      "implementation": "drift/input.touchHeld"
+    },
+    {
+      "module": "drift/input",
+      "name": "touchTap",
+      "signature": "fn(touch: Touch) -> bool",
+      "params": [
+        {
+          "name": "touch",
+          "type": "Touch"
+        }
+      ],
+      "returns": "bool",
+      "effects": [
+        "input.read"
+      ],
+      "deterministic": false,
+      "doc": "Whether the action side was tapped since this was last asked. True once per tap, so ask it once a tick.",
+      "implementation": "drift/input.touchTap"
+    },
+    {
+      "module": "drift/input",
+      "name": "touchSlide",
+      "signature": "fn(touch: Touch) -> bool",
+      "params": [
+        {
+          "name": "touch",
+          "type": "Touch"
+        }
+      ],
+      "returns": "bool",
+      "effects": [
+        "input.read"
+      ],
+      "deterministic": false,
+      "doc": "Whether a downward flick on the action side is being held: the secondary, a slide or a crouch.",
+      "implementation": "drift/input.touchSlide"
+    },
     {
       "module": "drift/navigation",
       "name": "nearest",
@@ -5777,28 +5998,6 @@
       "doc": "The world's gravity, in metres per second squared.",
       "implementation": "drift/physics.setGravity"
     },
-    {
-      "module": "drift/prefab",
-      "name": "spawn",
-      "signature": "fn(world: World, prefab: String) -> Entity",
-      "params": [
-        {
-          "name": "world",
-          "type": "World"
-        },
-        {
-          "name": "prefab",
-          "type": "String"
-        }
-      ],
-      "returns": "Entity",
-      "effects": [
-        "ecs.write"
-      ],
-      "deterministic": false,
-      "doc": "Make one, with every component the prefab names. Overrides are the host’s to apply; a script that wants a different value writes it after.",
-      "implementation": "drift/prefab.spawn"
-    },
     {
       "module": "drift/random",
       "name": "unit",
@@ -7637,6 +7836,11 @@
       "name": "Actions",
       "doc": "A bound action map: what the player is pressing."
     },
+    {
+      "module": "drift/input",
+      "name": "Touch",
+      "doc": "Touch controls: a stick on one side of the screen, and taps, holds and flicks on the other."
+    },
     {
       "module": "drift/camera",
       "name": "Camera",

package/dist/bindings/audio.d.ts

@@ -1,39 +1,4 @@
-/**
- * `drift/audio` — what this engine lets a script do to sound.
- *
- * **Five capabilities: a slot, two ways to play it, and the two cheap positional helpers.** This
- * header read "playback, placement, the mix, and the rhythm the music is doing" until 2026-08-27,
- * and three of those four were never here — there is no mix verb, no rhythm verb, no HRTF-panned
- * source, no listener and no reverb zone. The sentence was written from *Track G's* deliverables
- * rather than from the list beneath it, which is the same failure `drift/physics` had one file
- * over, and the same one the first `drift/camera` binding had: a comment describing what a
- * subsystem ought to expose rather than what this array does.
- *
- * It is still the right first binding and still the thing that shows what a binding *is* — registry
- * entries describing capabilities the engine already has, plus a map of implementations the host
- * supplies at link time. **No new engine code.**
- *
- * **What is missing, and why it is not guessed at here.** `MixConsole`, `AudioListenerGraph`,
- * `SpatialSource` and `ReverbZone` are four stateful objects with lifetimes, and a script-side
- * surface for them is a design about handles and ownership rather than a table entry — who disposes
- * a source, what happens to its probe slot, whether a zone outlives the script that made it.
- * `docs/CAPABILITIES.md` §4 records it. Taking that badly would put a leak in front of every script
- * author, which is worse than a surface they can see is absent.
- *
- * Three constraints this surface inherits, none of them negotiable:
- *
- * - **`audio.write` is outside the determinism boundary.** `ARCHITECTURE.md` places audio there, so
- *   a `@deterministic` function may not call any of it. A simulation decides *that* a door opened
- *   and emits an event; something outside the fixed step decides what it sounds like. The compiler
- *   is only making a line that already exists visible.
- * - **`audio.play` in a `@hot` function is a diagnostic**, for the reason the engine's own rules
- *   forbid allocation there.
- * - **A sound slot may be absent, so `sound` returns an option.** The registry probes several
- *   format candidates per slot and the file often is not there. A script that ignores that plays
- *   silence and reports success, which is the failure the language's no-implicit-null rule exists
- *   to prevent — and this is the first place in the engine where that rule earns its keep.
- */
-import { AudioGraph, SoundRegistry } from '@driftengine/audio';
+import type { AudioGraph, KickDetector, SoundRegistry } from '@driftengine/audio';
 import { type CapabilityDefinition, type OpaqueType } from 'driftscript';
 export declare const AUDIO_MODULE = "drift/audio";
 /**
@@ -53,4 +18,4 @@ export declare const AUDIO_CAPABILITIES: readonly CapabilityDefinition[];
  * registry's `implementation` strings name these; nothing enforces that mechanically, which is why
  * a test asserts every definition has an implementation here.
  */
-export declare function audioImplementation(graph: AudioGraph, registry: SoundRegistry): Record<string, unknown>;
+export declare function audioImplementation(graph: AudioGraph, registry: SoundRegistry, kick?: KickDetector | null): Record<string, unknown>;

package/dist/bindings/audio.js

@@ -1,10 +1,11 @@
 /**
  * `drift/audio` — what this engine lets a script do to sound.
  *
- * **Five capabilities: a slot, two ways to play it, and the two cheap positional helpers.** This
+ * **Nine capabilities: a slot, two ways to play it, the two cheap positional helpers, three dials on
+ * the mix, and the kick the music is making.** The first five are the original binding. This
  * header read "playback, placement, the mix, and the rhythm the music is doing" until 2026-08-27,
- * and three of those four were never here — there is no mix verb, no rhythm verb, no HRTF-panned
- * source, no listener and no reverb zone. The sentence was written from *Track G's* deliverables
+ * and three of those four were not here then — no mix verb, no rhythm verb, no HRTF-panned source,
+ * no listener and no reverb zone. The sentence was written from *Track G's* deliverables
  * rather than from the list beneath it, which is the same failure `drift/physics` had one file
  * over, and the same one the first `drift/camera` binding had: a comment describing what a
  * subsystem ought to expose rather than what this array does.
@@ -13,12 +14,18 @@
  * entries describing capabilities the engine already has, plus a map of implementations the host
  * supplies at link time. **No new engine code.**
  *
- * **What is missing, and why it is not guessed at here.** `MixConsole`, `AudioListenerGraph`,
- * `SpatialSource` and `ReverbZone` are four stateful objects with lifetimes, and a script-side
- * surface for them is a design about handles and ownership rather than a table entry — who disposes
- * a source, what happens to its probe slot, whether a zone outlives the script that made it.
- * `docs/CAPABILITIES.md` §4 records it. Taking that badly would put a leak in front of every script
- * author, which is worse than a surface they can see is absent.
+ * **The mix is bound as dials, by name.** `duck`, `fade` and `recall` move a bus or a snapshot the
+ * host already made, named by the string it was made under, and `pulse` reads a kick detector the
+ * host already runs. None of them hands a script an object, so none of them raises the question of
+ * who disposes it; a name nothing answers to is a `false`, never a silent success. The same rule
+ * `drift/render` follows: a dial is bound, and anything built from a table waits for a design.
+ *
+ * **What is missing, and why it is not guessed at here.** `AudioListenerGraph`, `SpatialSource` and
+ * `ReverbZone` are stateful objects with lifetimes, and a script-side surface for them is a design
+ * about handles and ownership rather than a table entry — who disposes a source, what happens to
+ * its probe slot, whether a zone outlives the script that made it. `docs/CAPABILITIES.md` §4
+ * records it. Taking that badly would put a leak in front of every script author, which is worse
+ * than a surface they can see is absent.
  *
  * Three constraints this surface inherits, none of them negotiable:
  *
@@ -33,7 +40,7 @@
  *   silence and reports success, which is the failure the language's no-implicit-null rule exists
  *   to prevent — and this is the first place in the engine where that rule earns its keep.
  */
-import { AudioGraph, SoundRegistry, distanceGain, stereoPan } from '@driftengine/audio';
+import { distanceGain, stereoPan } from '@driftengine/audio';
 import { defineCapability } from 'driftscript';
 export const AUDIO_MODULE = 'drift/audio';
 /**
@@ -97,6 +104,31 @@ export const AUDIO_CAPABILITIES = [
         { name: 'dz', type: 'f32' },
         { name: 'yaw', type: 'f32' },
     ], 'f32', ['pure'], true, 'Where something sits in the stereo field, relative to a listener facing yaw.', 'audio.stereoPan'),
+    define('duck', [
+        { name: 'bus', type: 'String' },
+        { name: 'factor', type: 'f32' },
+        { name: 'seconds', type: 'f32' },
+    ], 'bool', ['audio.write'], false, 'Take a bus down to factor of its fader over seconds, 1 to bring it back, leaving the fader ' +
+        'where the player set it. False when the mix has no bus of that name.', 'MixBus.duck'),
+    define('fade', [
+        { name: 'bus', type: 'String' },
+        { name: 'level', type: 'f32' },
+        { name: 'seconds', type: 'f32' },
+    ], 'bool', ['audio.write'], false, "Move a bus's fader to level over seconds. For a bus the game made: the music and effects " +
+        "faders are the player's, and duck is how a script goes over them. False when the mix has " +
+        'no bus of that name.', 'MixBus.fadeLevel'),
+    define('recall', [
+        { name: 'snapshot', type: 'String' },
+        { name: 'seconds', type: 'f32' },
+    ], 'bool', ['audio.write'], false, 'Crossfade every level, mute and send to a snapshot the host captured, over seconds. False ' +
+        'when nothing was captured under that name.', 'MixConsole.recall'),
+    define('pulse', [], 'f32', 
+    /*
+     * Read from the music as it plays, so a replay hears whatever the speakers did: outside the
+     * determinism boundary for the same reason playing a sound is.
+     */
+    ['nondeterministic'], false, 'How hard the music is kicking, 0 to 1, spiking on each kick and falling back. 0 when the ' +
+        'host runs no kick detector.', 'KickDetector.pulse'),
 ];
 const some = (value) => ({ tag: 'some', value });
 const none = { tag: 'none' };
@@ -108,7 +140,8 @@ const none = { tag: 'none' };
  * registry's `implementation` strings name these; nothing enforces that mechanically, which is why
  * a test asserts every definition has an implementation here.
  */
-export function audioImplementation(graph, registry) {
+export function audioImplementation(graph, registry, kick = null) {
+    const mix = graph.console;
     return {
         sound(slot) {
             const buffer = registry.get(slot);
@@ -122,5 +155,21 @@ export function audioImplementation(graph, registry) {
         },
         distanceGain,
         stereoPan,
+        duck(bus, factor, seconds) {
+            const found = mix.find(bus);
+            found?.duck(factor, seconds);
+            return found !== undefined;
+        },
+        fade(bus, level, seconds) {
+            const found = mix.find(bus);
+            found?.fadeLevel(level, seconds);
+            return found !== undefined;
+        },
+        recall(snapshot, seconds) {
+            return mix.recall(snapshot, seconds);
+        },
+        pulse() {
+            return kick?.pulse ?? 0;
+        },
     };
 }

package/dist/bindings/chemistry.js

@@ -103,6 +103,7 @@ export const CHEMISTRY_CAPABILITIES = [
     define('charFraction', [P, PARCEL], 'f32', READ, 'Share of the parcel that is now carbon, 0 to 1.'),
     define('charDepth', [P, PARCEL], 'f32', READ, 'Metres of char measured inward from the surface.'),
     define('wetness', [P, PARCEL], 'f32', READ, 'kg of liquid water on the surface, per square metre of it.'),
+    define('wettable', [P, PARCEL], 'bool', READ, 'Whether this material can hold liquid water, which is what `wet` asks. Rain over everything asks first, since `wet` refuses an iron nail.'),
     define('phase', [P, PARCEL], 'i32', READ, '0 solid, 1 liquid, 2 gas, 3 mixed. Mixed is a real answer: wet wood is a solid and a liquid at once.'),
     define('burning', [P, PARCEL], 'bool', READ, 'Whether a flame stands over it.'),
     define('smouldering', [P, PARCEL], 'bool', READ, 'Whether it is glowing with no flame. A smoulder survives air a flame cannot, which is why smothering leaves embers.'),
@@ -211,6 +212,7 @@ export function chemistryImplementation(services) {
         charFraction: (_, parcel) => parcels.charFractionOf(parcel),
         charDepth: (_, parcel) => parcels.charDepthOf(parcel),
         wetness: (_, parcel) => parcels.wetnessOf(parcel),
+        wettable: (_, parcel) => parcels.wettable(parcel),
         phase: (_, parcel) => parcels.parcelPhaseOf(parcel),
         burning: (_, parcel) => parcels.burning(parcel),
         smouldering: (_, parcel) => parcels.smouldering(parcel),

package/dist/bindings/core.d.ts

@@ -127,7 +127,17 @@ export declare const SCENE_CAPABILITIES: readonly CapabilityDefinition[];
  * accessor.
  */
 export declare const PHYSICS_CAPABILITIES: readonly CapabilityDefinition[];
-/** `drift/input` — Track H, complete: action maps, rebinding, gamepad, pointer and touch. */
+/**
+ * `drift/input` — what the player is doing, read through an action map or a touch screen, and the
+ * pad's motors.
+ *
+ * **This header said "action maps, rebinding, gamepad, pointer and touch" over an array that bound
+ * only the action reads and rumble**, the failure `docs/CAPABILITIES.md` §4 names for three other
+ * binding files. Touch is bound now, as a `Touch` handle beside `Actions`, because a scripted game
+ * was otherwise undriveable on a phone: `TouchControls` reports to nothing an action map reads.
+ * Rebinding and the pointer stay with the host. A controls screen is the game's own interface, and
+ * `ActionMap.rebind` changes what a script's `Actions` answer without the script knowing.
+ */
 export declare const INPUT_CAPABILITIES: readonly CapabilityDefinition[];
 /**
  * `drift/camera` — the cinematic cameras, and **only what they actually have**.

package/dist/bindings/core.js

@@ -74,6 +74,11 @@ export const CORE_TYPES = [
         name: 'Actions',
         doc: 'A bound action map: what the player is pressing.',
     },
+    {
+        module: INPUT_MODULE,
+        name: 'Touch',
+        doc: 'Touch controls: a stick on one side of the screen, and taps, holds and flicks on the other.',
+    },
     { module: CAMERA_MODULE, name: 'Camera', doc: 'A cinematic camera.' },
     {
         module: EVENTS_MODULE,
@@ -431,7 +436,17 @@ export const PHYSICS_CAPABILITIES = [
         { name: 'z', type: 'f32' },
     ], 'void', ['physics.write'], false, "The world's gravity, in metres per second squared."),
 ];
-/** `drift/input` — Track H, complete: action maps, rebinding, gamepad, pointer and touch. */
+/**
+ * `drift/input` — what the player is doing, read through an action map or a touch screen, and the
+ * pad's motors.
+ *
+ * **This header said "action maps, rebinding, gamepad, pointer and touch" over an array that bound
+ * only the action reads and rumble**, the failure `docs/CAPABILITIES.md` §4 names for three other
+ * binding files. Touch is bound now, as a `Touch` handle beside `Actions`, because a scripted game
+ * was otherwise undriveable on a phone: `TouchControls` reports to nothing an action map reads.
+ * Rebinding and the pointer stay with the host. A controls screen is the game's own interface, and
+ * `ActionMap.rebind` changes what a script's `Actions` answer without the script knowing.
+ */
 export const INPUT_CAPABILITIES = [
     define(INPUT_MODULE, 'down', [
         { name: 'actions', type: 'Actions' },
@@ -488,6 +503,11 @@ export const INPUT_CAPABILITIES = [
         { name: 'weak', type: 'f32' },
     ], 'bool', ['host'], false, 'Rumble for a duration in milliseconds, at two magnitudes in [0, 1]: `strong` is the low-frequency motor and `weak` the high-frequency one. Answers whether the platform took it; false is a real answer, not an error.'),
     define(INPUT_MODULE, 'stopRumble', [{ name: 'actions', type: 'Actions' }], 'bool', ['host'], false, 'Stop whatever that pad is playing. Answers whether the platform took it.'),
+    define(INPUT_MODULE, 'touchX', [{ name: 'touch', type: 'Touch' }], 'f32', ['input.read'], false, "The touch stick's horizontal, -1 to 1, 0 while no thumb is on it."),
+    define(INPUT_MODULE, 'touchY', [{ name: 'touch', type: 'Touch' }], 'f32', ['input.read'], false, "The touch stick's vertical, -1 to 1, up negative as a gamepad stick's is."),
+    define(INPUT_MODULE, 'touchHeld', [{ name: 'touch', type: 'Touch' }], 'bool', ['input.read'], false, 'Whether a thumb is held still on the action side of the screen: the held form of the primary.'),
+    define(INPUT_MODULE, 'touchTap', [{ name: 'touch', type: 'Touch' }], 'bool', ['input.read'], false, 'Whether the action side was tapped since this was last asked. True once per tap, so ask it once a tick.'),
+    define(INPUT_MODULE, 'touchSlide', [{ name: 'touch', type: 'Touch' }], 'bool', ['input.read'], false, 'Whether a downward flick on the action side is being held: the secondary, a slide or a crouch.'),
 ];
 /**
  * `drift/camera` — the cinematic cameras, and **only what they actually have**.
@@ -795,6 +815,11 @@ export function inputImplementation() {
         canRumble: (actions) => actions.canRumble,
         rumble: (actions, durationMs, strong, weak) => actions.rumble(durationMs, strong, weak),
         stopRumble: (actions) => actions.stopRumble(),
+        touchX: (touch) => f(touch.moveX),
+        touchY: (touch) => f(touch.moveY),
+        touchHeld: (touch) => touch.primaryHeld,
+        touchTap: (touch) => touch.consumePrimaryPress(),
+        touchSlide: (touch) => touch.secondaryHeld,
     };
 }
 export function cameraImplementation() {

package/dist/bindings/entities.d.ts

@@ -1,8 +1,10 @@
 /**
- * `drift/ecs` and `drift/prefab` — the entity model as DriftScript reaches it.
+ * `drift/ecs` — the entity model as DriftScript reaches it, prefabs included.
  *
- * These are the two surfaces the linker has refused by name since Track N shipped, and this file is
- * what kills that refusal. Like every binding here, nothing in it is new engine code: a binding is a
+ * This and `drift/prefab` were the two surfaces the linker refused by name until Track M shipped,
+ * and this file is what killed that refusal. `drift/prefab` is gone again: its one function was
+ * `spawn`, a keyword, so no script could call it, and making an entity from a prefab is
+ * `ecs.instantiate`. Like every binding here, nothing in it is new engine code: a binding is a
  * description and a lookup.
  *
  * ---
@@ -26,7 +28,6 @@
 import { type ComponentType, type Prefab } from '@driftengine/entities';
 import { type CapabilityDefinition, type OpaqueType } from 'driftscript';
 export declare const ECS_MODULE = "drift/ecs";
-export declare const PREFAB_MODULE = "drift/prefab";
 export declare const ENTITY_TYPES: readonly OpaqueType[];
 /**
  * An entity is `Entity`, and it took the language until DriftScript 1.6.0 to have the word.
@@ -56,7 +57,6 @@ export declare const ECS_CAPABILITIES: readonly CapabilityDefinition[];
  * generated code reaches them exactly as it reaches everything else, through `__bind($host)`.
  */
 export declare const QUERY_CAPABILITIES: readonly CapabilityDefinition[];
-export declare const PREFAB_CAPABILITIES: readonly CapabilityDefinition[];
 /** What a host supplies so a name can become a component type or a prefab. */
 export interface EntityServices {
     /**
@@ -66,8 +66,7 @@ export interface EntityServices {
      * with two worlds — a simulation and a preview — would otherwise need two hosts.
      */
     readonly components: ReadonlyMap<string, ComponentType>;
-    /** Prefabs by name. Absent when the host has none, which makes `drift/prefab` refuse in words. */
+    /** Prefabs by name. Absent when the host has none, which makes `instantiate` refuse in words. */
     readonly prefabs?: ReadonlyMap<string, Prefab>;
 }
 export declare function entitiesImplementation(services: EntityServices): Record<string, unknown>;
-export declare function prefabImplementation(services: EntityServices): Record<string, unknown>;

package/dist/bindings/entities.js

@@ -1,8 +1,10 @@
 /**
- * `drift/ecs` and `drift/prefab` — the entity model as DriftScript reaches it.
+ * `drift/ecs` — the entity model as DriftScript reaches it, prefabs included.
  *
- * These are the two surfaces the linker has refused by name since Track N shipped, and this file is
- * what kills that refusal. Like every binding here, nothing in it is new engine code: a binding is a
+ * This and `drift/prefab` were the two surfaces the linker refused by name until Track M shipped,
+ * and this file is what killed that refusal. `drift/prefab` is gone again: its one function was
+ * `spawn`, a keyword, so no script could call it, and making an entity from a prefab is
+ * `ecs.instantiate`. Like every binding here, nothing in it is new engine code: a binding is a
  * description and a lookup.
  *
  * ---
@@ -26,7 +28,6 @@
 import { ENTITY_INDEX_CEILING, instantiate, } from '@driftengine/entities';
 import { defineCapability } from 'driftscript';
 export const ECS_MODULE = 'drift/ecs';
-export const PREFAB_MODULE = 'drift/prefab';
 const define = (module, name, params, returns, effects, deterministic, doc) => defineCapability({
     module,
     name,
@@ -146,6 +147,16 @@ export const ECS_CAPABILITIES = [
         { name: 'radius', type: 'float' },
     ], 'bool', ['ecs.read'], true, "Whether any entity carrying a component has position fields putting it within a radius, and the search `nearest` then reads. **A linear scan of that component's column, not an index** — the entity model keeps no spatial structure, so this costs one pass over everything carrying the component. Position is read from three fields you name, so nothing here knows what a transform is called."),
     define(ECS_MODULE, 'nearest', [{ name: 'world', type: 'World' }], 'Entity', ['ecs.read'], true, 'The entity the last `findNearest` on this world found. **Valid only until the next one**, and meaningless when that answered false — the same lifetime a raycast hit has.'),
+    /*
+     * **Here and not in a `drift/prefab` of its own, because that one could not be called.** It was
+     * bound as `prefab.spawn`, and `prefab` and `spawn` are both keywords: `spawn` cannot even appear
+     * in an import list, so no script could reach it, and the target never provided the module
+     * either. A prefab is made into entities in a world, so the call belongs with the others that do.
+     */
+    define(ECS_MODULE, 'instantiate', [
+        { name: 'world', type: 'World' },
+        { name: 'prefab', type: 'String' },
+    ], 'Entity', ['ecs.write'], false, 'Make an entity from a prefab, with every component it names. Overrides are the host’s to apply; a script that wants a different value writes it after.'),
 ];
 /**
  * The four a query loop is built on.
@@ -174,14 +185,9 @@ export const QUERY_CAPABILITIES = [
         { name: 'forWriting', type: 'bool' },
     ], 'View', ['ecs.read'], true, 'A component’s live columns. `forWriting` decides which of a system’s declarations is checked — a loop that only reads takes a readable view, and asking for more than the system declared is refused.'),
 ];
-export const PREFAB_CAPABILITIES = [
-    define(PREFAB_MODULE, 'spawn', [
-        { name: 'world', type: 'World' },
-        { name: 'prefab', type: 'String' },
-    ], 'Entity', ['ecs.write'], false, 'Make one, with every component the prefab names. Overrides are the host’s to apply; a script that wants a different value writes it after.'),
-];
 export function entitiesImplementation(services) {
     const { components } = services;
+    const prefabs = services.prefabs ?? new Map();
     /**
      * Resolve a component name, or refuse naming what the world has.
      *
@@ -243,11 +249,15 @@ export function entitiesImplementation(services) {
             return step.done ? -1 : step.value;
         },
         view: (w, component, forWriting) => w.view(resolve(component), forWriting),
-        count: (w, component) => w.store(resolve(component)).size,
-        at: (w, component, index) => {
-            const store = w.store(resolve(component));
-            return index < store.size ? store.dense[index] : 0;
-        },
+        /*
+         * **Through the methods a system's view shares with a world, never a store.** Inside a system
+         * the value a script passes is the `SystemView` the schedule handed it, which has no `store`;
+         * reading `store.size` here threw the moment a system counted anything. The view checks the
+         * component against the system's declarations, which is the other thing a store would skip.
+         */
+        count: (w, component) => w.count(resolve(component)),
+        /* Zero past the end, as this has always answered; the walk's bound is `count`. */
+        at: (w, component, index) => Math.max(0, w.at(resolve(component), index)),
         /*
          * **A boolean rather than an option, and a second accessor for the handle.** `Sound?` is an
          * option because a slot is resolved once at load; this is written to be called every frame by
@@ -322,16 +332,11 @@ export function entitiesImplementation(services) {
          * is why the search answers one.
          */
         nearest: (w) => Math.max(0, found.get(w) ?? -1),
-    };
-}
-export function prefabImplementation(services) {
-    const prefabs = services.prefabs ?? new Map();
-    return {
-        spawn: (w, name) => {
+        instantiate: (w, name) => {
             const prefab = prefabs.get(name);
             if (prefab === undefined) {
-                throw new Error(`no prefab is registered as \`${name}\`. This host has ` +
-                    `${[...prefabs.keys()].map((k) => `\`${k}\``).join(', ')}.`);
+                const known = [...prefabs.keys()].map((k) => `\`${k}\``).join(', ');
+                throw new Error(`no prefab is registered as \`${name}\`. This host has ${known}.`);
             }
             return instantiate(w, prefab);
         },

package/dist/host.d.ts

@@ -35,7 +35,7 @@
  * A binding is cheap — a table entry and a lookup — and is the difference between a subsystem
  * a consumer can script and one they can only call from TypeScript.
  */
-import type { AudioGraph, SoundRegistry } from '@driftengine/audio';
+import type { AudioGraph, KickDetector, SoundRegistry } from '@driftengine/audio';
 import { type BehaviorServices } from './bindings/behavior.ts';
 import { type NavigationServices } from './bindings/navigation.ts';
 import { type CapabilityRegistry, type DriftModule, type TargetManifest } from 'driftscript';
@@ -87,9 +87,14 @@ export interface HostServices extends CoreServices {
      * one of those is a scene that draws and the other is a scene nobody is in.
      */
     readonly xr?: XrRuntime;
+    /**
+     * The mix a script plays into, the sounds it can name, and, when the game runs one, the kick
+     * detector `pulse` reads. The host calls the detector's `update` each frame; a script only reads.
+     */
     readonly audio?: {
         readonly graph: AudioGraph;
         readonly registry: SoundRegistry;
+        readonly kick?: KickDetector;
     };
     /**
      * The component types, and any prefabs, a script may name.

package/dist/host.js

@@ -13,7 +13,7 @@ import { XR_CAPABILITIES, XR_MODULE, XR_TYPES, xrImplementation, } from './bindi
 import { RENDER_CAPABILITIES, RENDER_MODULE, RENDER_TYPES, renderImplementation, } from './bindings/render.js';
 import { ANIMATION_CAPABILITIES, ANIMATION_MODULE, ANIMATION_TYPES, animationImplementation, } from './bindings/animation.js';
 import { CAMERA_CAPABILITIES, CAMERA_MODULE, CORE_TYPES, EVENTS_CAPABILITIES, EVENTS_MODULE, INPUT_CAPABILITIES, INPUT_MODULE, PERSISTENCE_CAPABILITIES, PERSISTENCE_MODULE, PHYSICS_CAPABILITIES, PHYSICS_MODULE, RANDOM_CAPABILITIES, RANDOM_MODULE, SCENE_CAPABILITIES, SCENE_MODULE, TIME_CAPABILITIES, TIME_MODULE, cameraImplementation, eventsImplementation, inputImplementation, persistenceImplementation, physicsImplementation, randomImplementation, sceneImplementation, timeImplementation, } from './bindings/core.js';
-import { ECS_CAPABILITIES, QUERY_CAPABILITIES, ECS_MODULE, ENTITY_TYPES, PREFAB_CAPABILITIES, PREFAB_MODULE, entitiesImplementation, prefabImplementation, } from './bindings/entities.js';
+import { ECS_CAPABILITIES, QUERY_CAPABILITIES, ECS_MODULE, ENTITY_TYPES, entitiesImplementation, } from './bindings/entities.js';
 import { CHEMISTRY_CAPABILITIES, CHEMISTRY_MODULE, CHEMISTRY_TYPES, chemistryImplementation, } from './bindings/chemistry.js';
 import { registerStd, stdImplementations } from 'driftscript/std';
 /**
@@ -97,7 +97,6 @@ export function engineRegistry() {
         ...NAVIGATION_CAPABILITIES,
         ...PERSISTENCE_CAPABILITIES,
         ...PHYSICS_CAPABILITIES,
-        ...PREFAB_CAPABILITIES,
         ...RANDOM_CAPABILITIES,
         ...RENDER_CAPABILITIES,
         ...XR_CAPABILITIES,
@@ -138,13 +137,12 @@ export function engineImplementations(services) {
        script that fails on `math.clamp` with the namespace undefined. */
     const map = { ...stdImplementations() };
     if (services.audio !== undefined) {
-        map[AUDIO_MODULE] = audioImplementation(services.audio.graph, services.audio.registry);
+        map[AUDIO_MODULE] = audioImplementation(services.audio.graph, services.audio.registry, services.audio.kick ?? null);
     }
     if (services.clocks !== undefined)
         map[TIME_MODULE] = timeImplementation(services.clocks);
     if (services.entities !== undefined) {
         map[ECS_MODULE] = entitiesImplementation(services.entities);
-        map[PREFAB_MODULE] = prefabImplementation(services.entities);
     }
     /*
      * These four take their handle as an argument rather than from the host, so they need nothing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driftengine/script",
-  "version": "4.7.0",
+  "version": "4.7.1",
   "description": "The drift/* capability bindings: what this engine provides to DriftScript, and the only place the two are coupled",
   "license": "Apache-2.0",
   "type": "module",
@@ -31,17 +31,17 @@
     "driftscript": "1.13.0"
   },
   "peerDependencies": {
-    "@driftengine/ai": "4.7.0",
-    "@driftengine/animation": "4.7.0",
-    "@driftengine/audio": "4.7.0",
-    "@driftengine/chemistry": "4.7.0",
-    "@driftengine/core": "4.7.0",
-    "@driftengine/editor": "4.7.0",
-    "@driftengine/entities": "4.7.0",
-    "@driftengine/network": "4.7.0",
-    "@driftengine/terrain": "4.7.0",
-    "@driftengine/ui2d": "4.7.0",
-    "@driftengine/xr": "4.7.0"
+    "@driftengine/ai": "4.7.1",
+    "@driftengine/animation": "4.7.1",
+    "@driftengine/audio": "4.7.1",
+    "@driftengine/chemistry": "4.7.1",
+    "@driftengine/core": "4.7.1",
+    "@driftengine/editor": "4.7.1",
+    "@driftengine/entities": "4.7.1",
+    "@driftengine/network": "4.7.1",
+    "@driftengine/terrain": "4.7.1",
+    "@driftengine/ui2d": "4.7.1",
+    "@driftengine/xr": "4.7.1"
   },
   "author": "Drift Technologies",
   "repository": {

package/src/bindings/audio.ts

@@ -1,10 +1,11 @@
 /**
  * `drift/audio` — what this engine lets a script do to sound.
  *
- * **Five capabilities: a slot, two ways to play it, and the two cheap positional helpers.** This
+ * **Nine capabilities: a slot, two ways to play it, the two cheap positional helpers, three dials on
+ * the mix, and the kick the music is making.** The first five are the original binding. This
  * header read "playback, placement, the mix, and the rhythm the music is doing" until 2026-08-27,
- * and three of those four were never here — there is no mix verb, no rhythm verb, no HRTF-panned
- * source, no listener and no reverb zone. The sentence was written from *Track G's* deliverables
+ * and three of those four were not here then — no mix verb, no rhythm verb, no HRTF-panned source,
+ * no listener and no reverb zone. The sentence was written from *Track G's* deliverables
  * rather than from the list beneath it, which is the same failure `drift/physics` had one file
  * over, and the same one the first `drift/camera` binding had: a comment describing what a
  * subsystem ought to expose rather than what this array does.
@@ -13,12 +14,18 @@
  * entries describing capabilities the engine already has, plus a map of implementations the host
  * supplies at link time. **No new engine code.**
  *
- * **What is missing, and why it is not guessed at here.** `MixConsole`, `AudioListenerGraph`,
- * `SpatialSource` and `ReverbZone` are four stateful objects with lifetimes, and a script-side
- * surface for them is a design about handles and ownership rather than a table entry — who disposes
- * a source, what happens to its probe slot, whether a zone outlives the script that made it.
- * `docs/CAPABILITIES.md` §4 records it. Taking that badly would put a leak in front of every script
- * author, which is worse than a surface they can see is absent.
+ * **The mix is bound as dials, by name.** `duck`, `fade` and `recall` move a bus or a snapshot the
+ * host already made, named by the string it was made under, and `pulse` reads a kick detector the
+ * host already runs. None of them hands a script an object, so none of them raises the question of
+ * who disposes it; a name nothing answers to is a `false`, never a silent success. The same rule
+ * `drift/render` follows: a dial is bound, and anything built from a table waits for a design.
+ *
+ * **What is missing, and why it is not guessed at here.** `AudioListenerGraph`, `SpatialSource` and
+ * `ReverbZone` are stateful objects with lifetimes, and a script-side surface for them is a design
+ * about handles and ownership rather than a table entry — who disposes a source, what happens to
+ * its probe slot, whether a zone outlives the script that made it. `docs/CAPABILITIES.md` §4
+ * records it. Taking that badly would put a leak in front of every script author, which is worse
+ * than a surface they can see is absent.
  *
  * Three constraints this surface inherits, none of them negotiable:
  *
@@ -33,7 +40,8 @@
  *   silence and reports success, which is the failure the language's no-implicit-null rule exists
  *   to prevent — and this is the first place in the engine where that rule earns its keep.
  */
-import { AudioGraph, SoundRegistry, distanceGain, stereoPan } from '@driftengine/audio';
+import { distanceGain, stereoPan } from '@driftengine/audio';
+import type { AudioGraph, KickDetector, SoundRegistry } from '@driftengine/audio';
 import { type CapabilityDefinition, type OpaqueType, defineCapability } from 'driftscript';
 
 export const AUDIO_MODULE = 'drift/audio';
@@ -148,6 +156,62 @@ export const AUDIO_CAPABILITIES: readonly CapabilityDefinition[] = [
     'Where something sits in the stereo field, relative to a listener facing yaw.',
     'audio.stereoPan',
   ),
+  define(
+    'duck',
+    [
+      { name: 'bus', type: 'String' },
+      { name: 'factor', type: 'f32' },
+      { name: 'seconds', type: 'f32' },
+    ],
+    'bool',
+    ['audio.write'],
+    false,
+    'Take a bus down to factor of its fader over seconds, 1 to bring it back, leaving the fader ' +
+      'where the player set it. False when the mix has no bus of that name.',
+    'MixBus.duck',
+  ),
+  define(
+    'fade',
+    [
+      { name: 'bus', type: 'String' },
+      { name: 'level', type: 'f32' },
+      { name: 'seconds', type: 'f32' },
+    ],
+    'bool',
+    ['audio.write'],
+    false,
+    "Move a bus's fader to level over seconds. For a bus the game made: the music and effects " +
+      "faders are the player's, and duck is how a script goes over them. False when the mix has " +
+      'no bus of that name.',
+    'MixBus.fadeLevel',
+  ),
+  define(
+    'recall',
+    [
+      { name: 'snapshot', type: 'String' },
+      { name: 'seconds', type: 'f32' },
+    ],
+    'bool',
+    ['audio.write'],
+    false,
+    'Crossfade every level, mute and send to a snapshot the host captured, over seconds. False ' +
+      'when nothing was captured under that name.',
+    'MixConsole.recall',
+  ),
+  define(
+    'pulse',
+    [],
+    'f32',
+    /*
+     * Read from the music as it plays, so a replay hears whatever the speakers did: outside the
+     * determinism boundary for the same reason playing a sound is.
+     */
+    ['nondeterministic'],
+    false,
+    'How hard the music is kicking, 0 to 1, spiking on each kick and falling back. 0 when the ' +
+      'host runs no kick detector.',
+    'KickDetector.pulse',
+  ),
 ];
 
 /** How the runtime represents an option. Matches what the compiler generates for `some`/`none`. */
@@ -167,7 +231,9 @@ const none: Option<never> = { tag: 'none' };
 export function audioImplementation(
   graph: AudioGraph,
   registry: SoundRegistry,
+  kick: KickDetector | null = null,
 ): Record<string, unknown> {
+  const mix = graph.console;
   return {
     sound(slot: string): Option<AudioBuffer> {
       const buffer = registry.get(slot);
@@ -181,5 +247,21 @@ export function audioImplementation(
     },
     distanceGain,
     stereoPan,
+    duck(bus: string, factor: number, seconds: number): boolean {
+      const found = mix.find(bus);
+      found?.duck(factor, seconds);
+      return found !== undefined;
+    },
+    fade(bus: string, level: number, seconds: number): boolean {
+      const found = mix.find(bus);
+      found?.fadeLevel(level, seconds);
+      return found !== undefined;
+    },
+    recall(snapshot: string, seconds: number): boolean {
+      return mix.recall(snapshot, seconds);
+    },
+    pulse(): number {
+      return kick?.pulse ?? 0;
+    },
   };
 }

package/src/bindings/chemistry.ts

@@ -189,6 +189,13 @@ export const CHEMISTRY_CAPABILITIES: readonly CapabilityDefinition[] = [
     READ,
     'kg of liquid water on the surface, per square metre of it.',
   ),
+  define(
+    'wettable',
+    [P, PARCEL],
+    'bool',
+    READ,
+    'Whether this material can hold liquid water, which is what `wet` asks. Rain over everything asks first, since `wet` refuses an iron nail.',
+  ),
   define(
     'phase',
     [P, PARCEL],
@@ -488,6 +495,7 @@ export function chemistryImplementation(services: ChemistryServices): Record<str
     charFraction: (_: unknown, parcel: number) => parcels.charFractionOf(parcel),
     charDepth: (_: unknown, parcel: number) => parcels.charDepthOf(parcel),
     wetness: (_: unknown, parcel: number) => parcels.wetnessOf(parcel),
+    wettable: (_: unknown, parcel: number) => parcels.wettable(parcel),
     phase: (_: unknown, parcel: number) => parcels.parcelPhaseOf(parcel),
     burning: (_: unknown, parcel: number) => parcels.burning(parcel),
     smouldering: (_: unknown, parcel: number) => parcels.smouldering(parcel),

package/src/bindings/core.ts

@@ -31,6 +31,7 @@ import {
   type QueuedMessage,
   type RayHit,
   SceneNode,
+  type TouchControls,
   type WindState,
   angleDelta,
   boxCollider,
@@ -106,6 +107,11 @@ export const CORE_TYPES: readonly OpaqueType[] = [
     name: 'Actions',
     doc: 'A bound action map: what the player is pressing.',
   },
+  {
+    module: INPUT_MODULE,
+    name: 'Touch',
+    doc: 'Touch controls: a stick on one side of the screen, and taps, holds and flicks on the other.',
+  },
   { module: CAMERA_MODULE, name: 'Camera', doc: 'A cinematic camera.' },
   {
     module: EVENTS_MODULE,
@@ -1018,7 +1024,17 @@ export const PHYSICS_CAPABILITIES: readonly CapabilityDefinition[] = [
   ),
 ];
 
-/** `drift/input` — Track H, complete: action maps, rebinding, gamepad, pointer and touch. */
+/**
+ * `drift/input` — what the player is doing, read through an action map or a touch screen, and the
+ * pad's motors.
+ *
+ * **This header said "action maps, rebinding, gamepad, pointer and touch" over an array that bound
+ * only the action reads and rumble**, the failure `docs/CAPABILITIES.md` §4 names for three other
+ * binding files. Touch is bound now, as a `Touch` handle beside `Actions`, because a scripted game
+ * was otherwise undriveable on a phone: `TouchControls` reports to nothing an action map reads.
+ * Rebinding and the pointer stay with the host. A controls screen is the game's own interface, and
+ * `ActionMap.rebind` changes what a script's `Actions` answer without the script knowing.
+ */
 export const INPUT_CAPABILITIES: readonly CapabilityDefinition[] = [
   define(
     INPUT_MODULE,
@@ -1147,6 +1163,51 @@ export const INPUT_CAPABILITIES: readonly CapabilityDefinition[] = [
     false,
     'Stop whatever that pad is playing. Answers whether the platform took it.',
   ),
+  define(
+    INPUT_MODULE,
+    'touchX',
+    [{ name: 'touch', type: 'Touch' }],
+    'f32',
+    ['input.read'],
+    false,
+    "The touch stick's horizontal, -1 to 1, 0 while no thumb is on it.",
+  ),
+  define(
+    INPUT_MODULE,
+    'touchY',
+    [{ name: 'touch', type: 'Touch' }],
+    'f32',
+    ['input.read'],
+    false,
+    "The touch stick's vertical, -1 to 1, up negative as a gamepad stick's is.",
+  ),
+  define(
+    INPUT_MODULE,
+    'touchHeld',
+    [{ name: 'touch', type: 'Touch' }],
+    'bool',
+    ['input.read'],
+    false,
+    'Whether a thumb is held still on the action side of the screen: the held form of the primary.',
+  ),
+  define(
+    INPUT_MODULE,
+    'touchTap',
+    [{ name: 'touch', type: 'Touch' }],
+    'bool',
+    ['input.read'],
+    false,
+    'Whether the action side was tapped since this was last asked. True once per tap, so ask it once a tick.',
+  ),
+  define(
+    INPUT_MODULE,
+    'touchSlide',
+    [{ name: 'touch', type: 'Touch' }],
+    'bool',
+    ['input.read'],
+    false,
+    'Whether a downward flick on the action side is being held: the secondary, a slide or a crouch.',
+  ),
 ];
 
 /**
@@ -1583,6 +1644,11 @@ export function inputImplementation(): Record<string, unknown> {
     rumble: (actions: ActionMap, durationMs: number, strong: number, weak: number) =>
       actions.rumble(durationMs, strong, weak),
     stopRumble: (actions: ActionMap) => actions.stopRumble(),
+    touchX: (touch: TouchControls) => f(touch.moveX),
+    touchY: (touch: TouchControls) => f(touch.moveY),
+    touchHeld: (touch: TouchControls) => touch.primaryHeld,
+    touchTap: (touch: TouchControls) => touch.consumePrimaryPress(),
+    touchSlide: (touch: TouchControls) => touch.secondaryHeld,
   };
 }
 

package/src/bindings/entities.ts

@@ -1,8 +1,10 @@
 /**
- * `drift/ecs` and `drift/prefab` — the entity model as DriftScript reaches it.
+ * `drift/ecs` — the entity model as DriftScript reaches it, prefabs included.
  *
- * These are the two surfaces the linker has refused by name since Track N shipped, and this file is
- * what kills that refusal. Like every binding here, nothing in it is new engine code: a binding is a
+ * This and `drift/prefab` were the two surfaces the linker refused by name until Track M shipped,
+ * and this file is what killed that refusal. `drift/prefab` is gone again: its one function was
+ * `spawn`, a keyword, so no script could call it, and making an entity from a prefab is
+ * `ecs.instantiate`. Like every binding here, nothing in it is new engine code: a binding is a
  * description and a lookup.
  *
  * ---
@@ -30,13 +32,13 @@ import {
   type Entity,
   type Prefab,
   type QueryCursor,
+  type SystemView,
   type World,
   instantiate,
 } from '@driftengine/entities';
 import { type CapabilityDefinition, type OpaqueType, defineCapability } from 'driftscript';
 
 export const ECS_MODULE = 'drift/ecs';
-export const PREFAB_MODULE = 'drift/prefab';
 
 const define = (
   module: string,
@@ -264,6 +266,24 @@ export const ECS_CAPABILITIES: readonly CapabilityDefinition[] = [
     true,
     'The entity the last `findNearest` on this world found. **Valid only until the next one**, and meaningless when that answered false — the same lifetime a raycast hit has.',
   ),
+  /*
+   * **Here and not in a `drift/prefab` of its own, because that one could not be called.** It was
+   * bound as `prefab.spawn`, and `prefab` and `spawn` are both keywords: `spawn` cannot even appear
+   * in an import list, so no script could reach it, and the target never provided the module
+   * either. A prefab is made into entities in a world, so the call belongs with the others that do.
+   */
+  define(
+    ECS_MODULE,
+    'instantiate',
+    [
+      { name: 'world', type: 'World' },
+      { name: 'prefab', type: 'String' },
+    ],
+    'Entity',
+    ['ecs.write'],
+    false,
+    'Make an entity from a prefab, with every component it names. Overrides are the host’s to apply; a script that wants a different value writes it after.',
+  ),
 ];
 
 /**
@@ -326,21 +346,6 @@ export const QUERY_CAPABILITIES: readonly CapabilityDefinition[] = [
   ),
 ];
 
-export const PREFAB_CAPABILITIES: readonly CapabilityDefinition[] = [
-  define(
-    PREFAB_MODULE,
-    'spawn',
-    [
-      { name: 'world', type: 'World' },
-      { name: 'prefab', type: 'String' },
-    ],
-    'Entity',
-    ['ecs.write'],
-    false,
-    'Make one, with every component the prefab names. Overrides are the host’s to apply; a script that wants a different value writes it after.',
-  ),
-];
-
 /** What a host supplies so a name can become a component type or a prefab. */
 export interface EntityServices {
   /**
@@ -350,12 +355,13 @@ export interface EntityServices {
    * with two worlds — a simulation and a preview — would otherwise need two hosts.
    */
   readonly components: ReadonlyMap<string, ComponentType>;
-  /** Prefabs by name. Absent when the host has none, which makes `drift/prefab` refuse in words. */
+  /** Prefabs by name. Absent when the host has none, which makes `instantiate` refuse in words. */
   readonly prefabs?: ReadonlyMap<string, Prefab>;
 }
 
 export function entitiesImplementation(services: EntityServices): Record<string, unknown> {
   const { components } = services;
+  const prefabs = services.prefabs ?? new Map<string, Prefab>();
 
   /**
    * Resolve a component name, or refuse naming what the world has.
@@ -388,7 +394,7 @@ export function entitiesImplementation(services: EntityServices): Record<string,
   return {
     create: (w: World) => w.create(),
     destroy: (w: World, entity: Entity) => w.destroy(entity),
-    alive: (w: World, entity: Entity) => w.alive(entity),
+    alive: (w: SystemView, entity: Entity) => w.alive(entity),
     has: (w: World, entity: Entity, component: string) => w.has(entity, resolve(component)),
     attach: (w: World, entity: Entity, component: string) => w.add(entity, resolve(component)),
     detach: (w: World, entity: Entity, component: string) => w.remove(entity, resolve(component)),
@@ -429,11 +435,16 @@ export function entitiesImplementation(services: EntityServices): Record<string,
     },
     view: (w: QuerySource, component: string, forWriting: boolean) =>
       w.view(resolve(component), forWriting),
-    count: (w: World, component: string) => w.store(resolve(component)).size,
-    at: (w: World, component: string, index: number) => {
-      const store = w.store(resolve(component));
-      return index < store.size ? (store.dense[index] as number) : 0;
-    },
+    /*
+     * **Through the methods a system's view shares with a world, never a store.** Inside a system
+     * the value a script passes is the `SystemView` the schedule handed it, which has no `store`;
+     * reading `store.size` here threw the moment a system counted anything. The view checks the
+     * component against the system's declarations, which is the other thing a store would skip.
+     */
+    count: (w: SystemView, component: string) => w.count(resolve(component)),
+    /* Zero past the end, as this has always answered; the walk's bound is `count`. */
+    at: (w: SystemView, component: string, index: number) =>
+      Math.max(0, w.at(resolve(component), index)),
     /*
      * **A boolean rather than an option, and a second accessor for the handle.** `Sound?` is an
      * option because a slot is resolved once at load; this is written to be called every frame by
@@ -517,6 +528,14 @@ export function entitiesImplementation(services: EntityServices): Record<string,
      * is why the search answers one.
      */
     nearest: (w: QuerySource) => Math.max(0, found.get(w) ?? -1),
+    instantiate: (w: World, name: string) => {
+      const prefab = prefabs.get(name);
+      if (prefab === undefined) {
+        const known = [...prefabs.keys()].map((k) => `\`${k}\``).join(', ');
+        throw new Error(`no prefab is registered as \`${name}\`. This host has ${known}.`);
+      }
+      return instantiate(w, prefab);
+    },
   };
 }
 
@@ -532,19 +551,3 @@ interface QuerySource {
   query(a: ComponentType, b?: ComponentType, c?: ComponentType, d?: ComponentType): QueryCursor;
   view(type: ComponentType, forWriting: boolean): ComponentView;
 }
-
-export function prefabImplementation(services: EntityServices): Record<string, unknown> {
-  const prefabs = services.prefabs ?? new Map<string, Prefab>();
-  return {
-    spawn: (w: World, name: string) => {
-      const prefab = prefabs.get(name);
-      if (prefab === undefined) {
-        throw new Error(
-          `no prefab is registered as \`${name}\`. This host has ` +
-            `${[...prefabs.keys()].map((k) => `\`${k}\``).join(', ')}.`,
-        );
-      }
-      return instantiate(w, prefab);
-    },
-  };
-}

package/src/host.ts

@@ -35,7 +35,7 @@
  * A binding is cheap — a table entry and a lookup — and is the difference between a subsystem
  * a consumer can script and one they can only call from TypeScript.
  */
-import type { AudioGraph, SoundRegistry } from '@driftengine/audio';
+import type { AudioGraph, KickDetector, SoundRegistry } from '@driftengine/audio';
 import {
   BEHAVIOR_CAPABILITIES,
   BEHAVIOR_MODULE,
@@ -161,10 +161,7 @@ import {
   ECS_MODULE,
   ENTITY_TYPES,
   type EntityServices,
-  PREFAB_CAPABILITIES,
-  PREFAB_MODULE,
   entitiesImplementation,
-  prefabImplementation,
 } from './bindings/entities.ts';
 import {
   CHEMISTRY_CAPABILITIES,
@@ -259,7 +256,6 @@ export function engineRegistry(): CapabilityRegistry {
     ...NAVIGATION_CAPABILITIES,
     ...PERSISTENCE_CAPABILITIES,
     ...PHYSICS_CAPABILITIES,
-    ...PREFAB_CAPABILITIES,
     ...RANDOM_CAPABILITIES,
     ...RENDER_CAPABILITIES,
     ...XR_CAPABILITIES,
@@ -304,7 +300,15 @@ export interface HostServices extends CoreServices {
    * one of those is a scene that draws and the other is a scene nobody is in.
    */
   readonly xr?: XrRuntime;
-  readonly audio?: { readonly graph: AudioGraph; readonly registry: SoundRegistry };
+  /**
+   * The mix a script plays into, the sounds it can name, and, when the game runs one, the kick
+   * detector `pulse` reads. The host calls the detector's `update` each frame; a script only reads.
+   */
+  readonly audio?: {
+    readonly graph: AudioGraph;
+    readonly registry: SoundRegistry;
+    readonly kick?: KickDetector;
+  };
   /**
    * The component types, and any prefabs, a script may name.
    *
@@ -358,12 +362,15 @@ export function engineImplementations(services: HostServices): Record<string, un
   const map: Record<string, unknown> = { ...stdImplementations() };
 
   if (services.audio !== undefined) {
-    map[AUDIO_MODULE] = audioImplementation(services.audio.graph, services.audio.registry);
+    map[AUDIO_MODULE] = audioImplementation(
+      services.audio.graph,
+      services.audio.registry,
+      services.audio.kick ?? null,
+    );
   }
   if (services.clocks !== undefined) map[TIME_MODULE] = timeImplementation(services.clocks);
   if (services.entities !== undefined) {
     map[ECS_MODULE] = entitiesImplementation(services.entities);
-    map[PREFAB_MODULE] = prefabImplementation(services.entities);
   }
 
   /*