@driftengine/core 4.7.4 → 4.8.1

package/CHANGELOG.json

@@ -1,4 +1,61 @@
 [
+  {
+    "version": "4.8.1",
+    "date": "2026-10-03",
+    "entries": [
+      {
+        "kind": "fixed",
+        "short": "A character controller is stopped by a beam at head height, and a capsule meets a box that only its middle or its top would touch, where it passed through.",
+        "text": "Two defects in the narrow phase, which together let a standing 1.8 m capsule walk through a beam from 1.4 to 1.7 m. A capsule against a box was measured from the two balls at the ends of its segment only, so a slab across its middle, which neither ball reaches, was not there at all; the closest point inside the segment is now found wherever the ends are not the answer, which costs nothing for a capsule standing on a floor or lying on a face. And `shapecast` advanced by the first contact's separation, which for a capsule is its lower end, so a box that only the upper end would meet was never reached. It now advances by the nearest contact. `overlap` and the solver's contacts gain the interior point too, so a capsule body lying across a rail rests on it."
+      },
+      {
+        "kind": "fixed",
+        "short": "A character climbs any step up to its step height, where a rise nearly as tall as its radius stopped it at the edge.",
+        "text": "The forward part of a step is what is left of the tick's move when the body meets the step, and that can be millimetres. With a 0.32 m radius and a 0.35 m step height, a 0.25 m rise climbed and a 0.28 m one did not: the foot came down on the step's edge, a contact too steep to stand on, slid back off, and never tried again. A step that lands on an edge now carries the body over it, so the foot comes down on the top, which moves it up to one radius further in that tick than it was going to. `shapecast` also closes on a surface it approaches at a shallow angle, where its fixed number of advances ran out first and it reported nothing there: it now advances by how fast the two close along the normal that separates them, not by the whole travel."
+      }
+    ]
+  },
+  {
+    "version": "4.8.0",
+    "date": "2026-10-03",
+    "entries": [
+      {
+        "kind": "changed",
+        "short": "A drift/* answer that is one of a few things is an enum a script matches on: a contact, a phase of matter, a chemistry event, a tree's or a save's status, the editor's modes, a hand and its joints.",
+        "text": "Twelve enums are declared by the engine for DriftScript 1.15.0's host enums: `TreeStatus`, `MatterPhase`, `ChemistryEvent`, `ContactKind`, `SaveStatus`, `GizmoMode`, `GizmoSpace`, `GizmoHandle`, `EditorMode`, `FieldKind`, `Hand` and `HandJoint`. `behavior.tick`, `step` and `status`, `chemistry.phase` and `eventKind`, `physics.contactKind`, `persistence.saveStatus` and the editor's `gizmoMode`, `space`, `hovered`, `mode` and `fieldKind` answer a variant where they answered a number or a string, and `drift/xr` takes a `Hand` and a `HandJoint` where it took `\"right\"` and `\"index-finger-tip\"`. A script that compared one of these against a number or a string no longer compiles, which is the point: those comparisons were checked by nothing, and a misspelt joint read zero. Each variant list is tested against the engine constants it translates. `contactKind`, `eventKind` and `fieldKind` refuse an index past what exists, where they answered a stale entry or nothing."
+      },
+      {
+        "kind": "fixed",
+        "short": "An optional component field reads and writes as an option from a script, in a query loop and through a handle: a cleared one reads none, and writing one no longer stores NaN.",
+        "text": "**`driftscript` moves to 1.16.0.** A loop read only an optional field's value column and an assignment put the option object into it, which stored `NaN` marked present; through a handle the read answered a bare number. The compiler now reads and writes the presence column beside the value, and `drift/ecs`'s `read` answers `undefined` for an absent optional field where it answered zero, which the compiler turns into `none`. The entities example's frogs keep their target as an `Entity?`, where they kept a flag beside a plain `Entity` because of this."
+      },
+      {
+        "kind": "fixed",
+        "short": "A lockstep session whose player holds a control on the first tick stays in step: the ticks before anyone can publish an input are neutral on every peer, where each peer guessed its own.",
+        "text": "No peer can publish an input for the ticks before its first tick plus the input delay, so every peer guessed them and nothing ever corrected the guess. A guess repeats the newest input the log holds, and for a peer's own participant that was the input it had just submitted for a later tick, which the other peer cannot know. So a key held when the match began split the two worlds, and the first fingerprint halted the session. `LockstepSession` settles those ticks as neutral for every participant on its first `submit`."
+      },
+      {
+        "kind": "fixed",
+        "short": "WebSocketTransport takes a browser WebSocket as it is typed: the socket shape asked for any buffer, which a browser's send does not accept, so the package's own example did not compile.",
+        "text": "`SocketLike.send` and `DataChannelLike.send` take a view of an `ArrayBuffer`, which is what a browser's `WebSocket` and `RTCDataChannel` accept, and both transports copy a message on shared memory off it before sending, since a browser refuses to send one."
+      },
+      {
+        "kind": "added",
+        "short": "runSchedule takes a failure reporter: every system failure, every tick, with the system's name, the tick and the error, where it logged once per system and nothing else could see it.",
+        "text": "`runSchedule(world, schedule, tick, report)`. Without a reporter a failing system is still skipped and logged once per system per world, as before. With one, nothing is logged and the reporter decides: count failures, show them in an overlay, send them to telemetry, or throw to make a failure fatal while developing, which stops the schedule at that system."
+      },
+      {
+        "kind": "changed",
+        "short": "A system's component access follows its calls into other files, so DS0291 stops calling a correct declaration unused and an undeclared write is a compile error, not a refusal at runtime.",
+        "text": "From DriftScript 1.16.0. Access was inferred from a module's own functions, so a helper imported from another file touched nothing as far as a system was concerned: a declaration of what it wrote drew `DS0291`, and leaving it out drew no `DS0288` and left the write out of the metadata the engine builds its schedule from. And from 1.15.0, `==` compares what two values hold, so an enum variant still equals itself after a hot reload; it compared objects by identity, and a rule written `if round.phase != Phase.Playing` returned forever after the first save."
+      },
+      {
+        "kind": "added",
+        "short": "The manual gains a DriftScript section and a networking chapter: what a script is for, setting one up, patterns, everything it can reach, testing, and two peers in one match over a lossy link.",
+        "text": "**DriftScript in a game** says what belongs in a script and what stays in TypeScript, **Setting up scripts** covers the build, binding, services and hot reload, **Patterns** names the shapes the examples share, **What a script can reach** lists every module, function and enum from the capability file, and **Determinism, testing and shipping** covers `@deterministic`, testing a script in Node and what reaches the bundle. The starter and the first game keep their rules in `.drs` files, the starter carries the Vite config and declaration a copied project needs and builds without a warning, and the first game's round is tested in Node. **Networking and rollback** is built on the new netplay example: two peers in one page over an impaired loopback, with the link, the redundancy and the input delay as live switches."
+      }
+    ]
+  },
   {
     "version": "4.7.4",
     "date": "2026-10-02",

package/README.md

@@ -36,6 +36,9 @@ import {
   createRenderer,
   startLoop,
 } from '@driftengine/core';
+import { bindModule } from '@driftengine/script';
+import { loadModule, patchModule } from 'driftscript';
+import * as spinScript from './spin.drs';
 
 const canvas = document.querySelector<HTMLCanvasElement>('#stage');
 if (canvas === null) throw new Error('the page must carry <canvas id="stage">');
@@ -94,6 +97,22 @@ camera.position[1] = 4.5;
 camera.position[2] = 8;
 camera.lookAt(0, 1, 0);
 
+/*
+ * How fast the cube turns is a rule, and rules live in DriftScript: `spin.drs`. The bundler compiles
+ * the file, `loadModule` makes a module of it, and `bindModule` gives it the engine capabilities it
+ * imports. Saving the file while the page is open replaces its function in place.
+ */
+const spinModule = loadModule(spinScript as Record<string, unknown>);
+const bound = bindModule(spinModule, {});
+if (!bound.bound) throw new Error(bound.reason);
+const rules = spinModule.exports as unknown as { spinRate(time: number): number };
+
+if (import.meta.hot) {
+  import.meta.hot.accept('./spin.drs', (next) => {
+    if (next !== undefined) patchModule(spinModule, next as Record<string, unknown>);
+  });
+}
+
 /*
  * Two angles, because that is what `alpha` is for. The simulation advances in fixed steps and
  * the display does not, so a frame almost never lands on a step boundary: drawing `spin`
@@ -102,11 +121,13 @@ camera.lookAt(0, 1, 0);
  */
 let spin = 0;
 let previousSpin = 0;
+let time = 0;
 
 startLoop({
   simulate(dt) {
     previousSpin = spin;
-    spin += dt * 0.8;
+    time += dt;
+    spin += dt * rules.spinRate(time);
   },
   render(alpha) {
     spinner.setRotationAxisAngle(0, 1, 0, previousSpin + (spin - previousSpin) * alpha);
@@ -123,6 +144,26 @@ startLoop({
 });
 ```
 
+How fast the cube turns is a rule, so it lives in DriftScript, in `spin.drs` beside the page:
+
+```drs
+// How the cube turns. The page owns the cube; this file only says how fast it goes.
+//
+// Save it while the page is open and the cube takes the new rate without the page reloading. Try a
+// steady 2, a cube that stops every few seconds, or one that turns the other way.
+
+import { sin } from "std/math"
+
+// Radians a second: a steady turn that quickens and eases every few seconds.
+fn spinRate(time: f32) -> f32 {
+    return 0.8 + 0.4 * math.sin(time * 0.5)
+}
+```
+
+The bundler compiles it with DriftScript's Vite plugin, set up as in the starter's `vite.config.ts`;
+[Installation](https://driftengine.dev/docs/start/installation#driftscript) has the two packages and
+the config.
+
 This is the engine's `examples/starter`, and a test keeps the two the same.
 [Hello world](https://driftengine.dev/docs/start/hello-world) walks through it, and
 [Your first game](https://driftengine.dev/docs/start/first-game) builds a complete one.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driftengine/core",
-  "version": "4.7.4",
+  "version": "4.8.1",
   "description": "The runtime of DriftEngine, a WebGPU game engine with a WebGL2 fallback: renderer, loop, input, cameras, scene graph and physics",
   "license": "Apache-2.0",
   "type": "module",
@@ -29,8 +29,8 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@driftengine/drft": "4.7.4",
-    "@driftengine/physics": "4.7.4",
+    "@driftengine/drft": "4.8.1",
+    "@driftengine/physics": "4.8.1",
     "gl-matrix": "^3.4.3"
   },
   "author": "Drift Technologies",
@@ -67,8 +67,8 @@
     "prepack": "node ../../scripts/build.mjs @driftengine/core"
   },
   "devDependencies": {
-    "@driftengine/nav": "4.7.4",
-    "@driftengine/network": "4.7.4",
-    "@driftengine/texture": "4.7.4"
+    "@driftengine/nav": "4.8.1",
+    "@driftengine/network": "4.8.1",
+    "@driftengine/texture": "4.8.1"
   }
 }