gloop-sim 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zurab Mujirishvili
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,112 @@
-# Temporary Holding Version
+<p align="center">
+    <a href="https://zurabm.gitlab.io/gloop/">
+        <img src="https://cdn.jsdelivr.net/npm/gloop-sim/docs/assets/logo.svg" width="180" alt="Gloop logo">
+    </a>
+</p>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![Pipeline Status](https://gitlab.com/zurabm/gloop/badges/main/pipeline.svg)](https://gitlab.com/zurabm/gloop/-/pipelines) [![Coverage](https://gitlab.com/zurabm/gloop/badges/main/coverage.svg)](https://gitlab.com/zurabm/gloop/-/pipelines) [![npm](https://img.shields.io/npm/v/gloop-sim)](https://www.npmjs.com/package/gloop-sim) [![Docs](https://img.shields.io/badge/docs-zurabm.gitlab.io%2Fgloop-blue)](https://zurabm.gitlab.io/gloop/) [![License](https://img.shields.io/npm/l/gloop-sim)](https://gitlab.com/zurabm/gloop/-/blob/main/LICENSE)
+
+# Gloop: A Swarm Simulation Library for the Browser
+
+Gloop simulates and renders particle swarms in the browser. A swarm is built from four parts: an initializer that places the particles, a model that defines the forces between them, an integrator that advances them in time, and a backend that runs the computation (using the CPU or GPU).
+
+The rendering API draws a swarm with [three.js](https://threejs.org/). The [docs site](https://zurabm.gitlab.io/gloop/) embeds an interactive lab where you can run swarms of different sizes and configurations.
+
+> Gloop is in early development, so some features are missing and parts of the API may change. You can help by [reporting issues](https://gitlab.com/zurabm/gloop/-/issues) or contributing fixes and features.
+
+## Installation
+
+```bash
+pnpm add gloop-sim three@0.185.1
+```
+
+`three` is a required peer dependency. The GPU backend needs WebGPU to be enabled in your browser.
+
+## Quick Start
+
+Here's a swarm of three particles connected by springs, simulated on the CPU:
+
+```ts
+import { gloop } from "gloop-sim";
+
+const swarm = await gloop.swarm({
+  particleCount: 3,
+  initializer: gloop.initializer.fixed({
+    positions: [
+      [0, 0, 0],
+      [1, 0, 0],
+      [0, 1, 0],
+    ],
+    velocities: [
+      [0, 0, 0],
+      [0, 0, 0],
+      [0, 0, 0],
+    ],
+  }),
+  model: gloop.model.elasticNetwork({
+    masses: [1, 1, 1],
+    connections: [
+      { between: [0, 1], restLength: 1 },
+      { between: [0, 2], restLength: 1 },
+      { between: [1, 2], restLength: Math.SQRT2 },
+    ],
+    stiffness: 40,
+    springDamping: 1.5,
+  }),
+  integrator: gloop.integrator.semiImplicitEuler(),
+  backend: gloop.backend.cpu(),
+});
+```
+
+Replacing `gloop.backend.cpu()` with `gloop.backend.gpu()` runs the same swarm on the GPU.
+
+<details>
+<summary><strong>Advancing the swarm and reading its state</strong></summary>
+
+<br>
+
+`advance` steps the simulation forward by the given amount of simulated time. `snapshot` reads the current state back, which is asynchronous because the GPU backend has to copy it from the device.
+
+```ts
+for (let step = 0; step < 30; step++) {
+  swarm.advance({ time: 1 / 60 });
+}
+
+const state = await swarm.snapshot();
+console.log(state.time, state.particles.positions);
+```
+
+</details>
+
+For a step-by-step walkthrough, see the [Getting started guide](https://zurabm.gitlab.io/gloop/guides/getting-started/).
+
+## Documentation
+
+|                                                                           |                                                         |
+| ------------------------------------------------------------------------- | ------------------------------------------------------- |
+| [Getting started](https://zurabm.gitlab.io/gloop/guides/getting-started/) | Installation, a first swarm, switching to the GPU       |
+| [Guides](https://zurabm.gitlab.io/gloop/guides/)                          | Core concepts, models and forces, integrators, backends |
+| [Rendering](https://zurabm.gitlab.io/gloop/guides/rendering/)             | Drawing a swarm and its springs with three.js           |
+| [API Reference](https://zurabm.gitlab.io/gloop/reference/core/)           | Every exported function and type                        |
+
+## Benchmarks
+
+```bash
+pnpm bench
+```
+
+This opens Chromium with WebGPU enabled and times both backends across a range of swarm sizes. Each run is archived to `generated/bench/runs/`, and the report is written to `generated/bench/report.html` with a text summary in `generated/bench/summary.md`.
+
+To compare two archived runs, rebuild the report with one as the baseline:
+
+```bash
+pnpm bench:report --run generated/bench/runs/<new>.json --baseline generated/bench/runs/<old>.json
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+MIT, see [LICENSE](LICENSE).

package/dist/assert.d.ts

@@ -0,0 +1 @@
+export declare function assert(condition: unknown, message: string): asserts condition;

package/dist/assert.js

@@ -0,0 +1,6 @@
+export function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}
+//# sourceMappingURL=assert.js.map

package/dist/assert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.js","sourceRoot":"","sources":["../src/assert.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,MAAM,CAAC,SAAkB,EAAE,OAAe;IACxD,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;AACH,CAAC","sourcesContent":["export function assert(condition: unknown, message: string): asserts condition {\n  if (!condition) {\n    throw new Error(message);\n  }\n}\n"]}

package/dist/backend/cpu.d.ts

@@ -0,0 +1,2 @@
+import type { Backend } from "../types.js";
+export declare function createCpuBackend(): Backend;

package/dist/backend/cpu.js

@@ -0,0 +1,23 @@
+import { assert } from "../assert.js";
+export function createCpuBackend() {
+    return {
+        compile({ particles, model, integrator }) {
+            const cpuModel = model.cpu;
+            assert(cpuModel !== undefined, "the model has no cpu implementation");
+            let current = particles;
+            return Promise.resolve({
+                step(seconds) {
+                    current = integrator.cpu.step({
+                        particles: current,
+                        accelerations: cpuModel.accelerate(current),
+                        seconds,
+                    });
+                },
+                snapshot() {
+                    return Promise.resolve(current);
+                },
+            });
+        },
+    };
+}
+//# sourceMappingURL=cpu.js.map

package/dist/backend/cpu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cpu.js","sourceRoot":"","sources":["../../src/backend/cpu.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAGrC,MAAM,UAAU,gBAAgB;IAC9B,OAAO;QACL,OAAO,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,UAAU,EAAkB;YACtD,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC;YAC3B,MAAM,CAAC,QAAQ,KAAK,SAAS,EAAE,qCAAqC,CAAC,CAAC;YAEtE,IAAI,OAAO,GAAG,SAAS,CAAC;YAExB,OAAO,OAAO,CAAC,OAAO,CAAC;gBACrB,IAAI,CAAC,OAAe;oBAClB,OAAO,GAAG,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC;wBAC5B,SAAS,EAAE,OAAO;wBAClB,aAAa,EAAE,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC;wBAC3C,OAAO;qBACR,CAAC,CAAC;gBACL,CAAC;gBACD,QAAQ;oBACN,OAAO,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;gBAClC,CAAC;aACF,CAAC,CAAC;QACL,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import { assert } from \"@/assert.js\";\nimport type { Backend, CompileOptions, Executable, Particles } from \"@/types.js\";\n\nexport function createCpuBackend(): Backend {\n  return {\n    compile({ particles, model, integrator }: CompileOptions): Promise<Executable> {\n      const cpuModel = model.cpu;\n      assert(cpuModel !== undefined, \"the model has no cpu implementation\");\n\n      let current = particles;\n\n      return Promise.resolve({\n        step(seconds: number): void {\n          current = integrator.cpu.step({\n            particles: current,\n            accelerations: cpuModel.accelerate(current),\n            seconds,\n          });\n        },\n        snapshot(): Promise<Particles> {\n          return Promise.resolve(current);\n        },\n      });\n    },\n  };\n}\n"]}

package/dist/backend/gpu.d.ts

@@ -0,0 +1,2 @@
+import type { Backend, GpuBackendOptions } from "../types.js";
+export declare function createGpuBackend({ device }?: GpuBackendOptions): Backend;

package/dist/backend/gpu.js

@@ -0,0 +1,145 @@
+import { Fn, instanceIndex, storage, uniform, vec4 } from "three/tsl";
+import { StorageBufferAttribute, WebGPURenderer } from "three/webgpu";
+import { assert } from "../assert.js";
+function bind(attribute, count) {
+    return storage(attribute, "vec4", count);
+}
+function secondsBuffer() {
+    return uniform(0);
+}
+var buffer;
+(function (buffer) {
+    const FLOATS_PER_VEC4 = 4;
+    function vector(vectors) {
+        const array = new Float32Array(vectors.length * FLOATS_PER_VEC4);
+        for (const [particle, vector] of vectors.entries()) {
+            array.set(vector, particle * FLOATS_PER_VEC4);
+        }
+        return new StorageBufferAttribute(array, FLOATS_PER_VEC4);
+    }
+    buffer.vector = vector;
+    function zeros(particleCount) {
+        return new StorageBufferAttribute(new Float32Array(particleCount * FLOATS_PER_VEC4), FLOATS_PER_VEC4);
+    }
+    buffer.zeros = zeros;
+    function decode(source, particleCount) {
+        const array = new Float32Array(source);
+        const vectors = [];
+        for (let particle = 0; particle < particleCount; particle++) {
+            const [x, y, z] = [
+                array[particle * FLOATS_PER_VEC4],
+                array[particle * FLOATS_PER_VEC4 + 1],
+                array[particle * FLOATS_PER_VEC4 + 2],
+            ];
+            assert(x !== undefined && y !== undefined && z !== undefined, `particle ${particle} is missing from the readback`);
+            vectors.push([x, y, z]);
+        }
+        return vectors;
+    }
+    buffer.decode = decode;
+})(buffer || (buffer = {}));
+function allocate(particles) {
+    const count = particles.count;
+    const positionAttribute = buffer.vector(particles.positions);
+    const velocityAttribute = buffer.vector(particles.velocities);
+    const accelerationAttribute = buffer.zeros(count);
+    return {
+        count,
+        positionAttribute,
+        velocityAttribute,
+        positions: bind(positionAttribute, count),
+        velocities: bind(velocityAttribute, count),
+        accelerations: bind(accelerationAttribute, count),
+    };
+}
+var pass;
+(function (pass) {
+    function accelerate(model, buffers) {
+        const particles = {
+            count: buffers.count,
+            position: (index) => buffers.positions.element(index).xyz,
+            velocity: (index) => buffers.velocities.element(index).xyz,
+        };
+        return Fn(() => {
+            buffers.accelerations
+                .element(instanceIndex)
+                .assign(vec4(model.acceleration({ particles, index: instanceIndex }), 0));
+        })().compute(buffers.count);
+    }
+    pass.accelerate = accelerate;
+    function integrate(integrator, buffers, seconds) {
+        return Fn(() => {
+            const particle = {
+                position: buffers.positions.element(instanceIndex).xyz.toVar(),
+                velocity: buffers.velocities.element(instanceIndex).xyz.toVar(),
+            };
+            const next = integrator.gpu.step({
+                particle,
+                acceleration: buffers.accelerations.element(instanceIndex).xyz,
+                seconds,
+            });
+            buffers.positions.element(instanceIndex).assign(vec4(next.position, 0));
+            buffers.velocities.element(instanceIndex).assign(vec4(next.velocity, 0));
+        })().compute(buffers.count);
+    }
+    pass.integrate = integrate;
+})(pass || (pass = {}));
+function executable(renderer, buffers, seconds, accelerate, integrate) {
+    let dispatched = false;
+    async function latestBuffer(attribute) {
+        return dispatched ? renderer.getArrayBufferAsync(attribute) : attribute.array.buffer;
+    }
+    return {
+        step(time) {
+            // Dispatching over a zero-sized storage buffer is a WebGPU validation error.
+            if (buffers.count === 0) {
+                return;
+            }
+            seconds.value = time;
+            renderer.compute([accelerate, integrate]);
+            dispatched = true;
+        },
+        async snapshot() {
+            const [positionBuffer, velocityBuffer] = await Promise.all([
+                latestBuffer(buffers.positionAttribute),
+                latestBuffer(buffers.velocityAttribute),
+            ]);
+            return {
+                count: buffers.count,
+                positions: buffer.decode(positionBuffer, buffers.count),
+                velocities: buffer.decode(velocityBuffer, buffers.count),
+            };
+        },
+    };
+}
+class SharedRenderer {
+    device;
+    renderer;
+    constructor(device) {
+        this.device = device;
+    }
+    acquire() {
+        this.renderer ??= this.initialize();
+        return this.renderer;
+    }
+    async initialize() {
+        const renderer = new WebGPURenderer({ forceWebGL: false, device: this.device });
+        await renderer.init();
+        return renderer;
+    }
+}
+export function createGpuBackend({ device } = {}) {
+    const shared = new SharedRenderer(device);
+    return {
+        async compile({ particles, model, integrator }) {
+            const gpuModel = model.gpu;
+            assert(gpuModel !== undefined, "the model has no gpu implementation");
+            const buffers = allocate(particles);
+            const seconds = secondsBuffer();
+            const accelerate = pass.accelerate(gpuModel, buffers);
+            const integrate = pass.integrate(integrator, buffers, seconds);
+            return executable(await shared.acquire(), buffers, seconds, accelerate, integrate);
+        },
+    };
+}
+//# sourceMappingURL=gpu.js.map

package/dist/backend/gpu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu.js","sourceRoot":"","sources":["../../src/backend/gpu.ts"],"names":[],"mappings":"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","sourcesContent":["import { Fn, instanceIndex, storage, uniform, vec4 } from \"three/tsl\";\nimport { StorageBufferAttribute, WebGPURenderer } from \"three/webgpu\";\nimport { assert } from \"@/assert.js\";\nimport type {\n  Backend,\n  CompileOptions,\n  Device,\n  Executable,\n  GpuBackendOptions,\n  GpuParticles,\n  Particles,\n  Vector,\n} from \"@/types.js\";\n\nfunction bind(attribute: StorageBufferAttribute, count: number) {\n  return storage(attribute, \"vec4\", count);\n}\n\nfunction secondsBuffer() {\n  return uniform(0);\n}\n\ntype StorageNode = ReturnType<typeof bind>;\ntype SecondsBuffer = ReturnType<typeof secondsBuffer>;\ntype GpuModel = NonNullable<CompileOptions[\"model\"][\"gpu\"]>;\ntype Integrator = CompileOptions[\"integrator\"];\ntype ComputePass = ReturnType<typeof pass.accelerate>;\n\ninterface Buffers {\n  count: number;\n  positionAttribute: StorageBufferAttribute;\n  velocityAttribute: StorageBufferAttribute;\n  positions: StorageNode;\n  velocities: StorageNode;\n  accelerations: StorageNode;\n}\n\nnamespace buffer {\n  const FLOATS_PER_VEC4 = 4;\n\n  export function vector(vectors: readonly Vector[]): StorageBufferAttribute {\n    const array = new Float32Array(vectors.length * FLOATS_PER_VEC4);\n\n    for (const [particle, vector] of vectors.entries()) {\n      array.set(vector, particle * FLOATS_PER_VEC4);\n    }\n\n    return new StorageBufferAttribute(array, FLOATS_PER_VEC4);\n  }\n\n  export function zeros(particleCount: number): StorageBufferAttribute {\n    return new StorageBufferAttribute(new Float32Array(particleCount * FLOATS_PER_VEC4), FLOATS_PER_VEC4);\n  }\n\n  export function decode(source: ArrayBufferLike, particleCount: number): readonly Vector[] {\n    const array = new Float32Array(source);\n    const vectors: Vector[] = [];\n\n    for (let particle = 0; particle < particleCount; particle++) {\n      const [x, y, z] = [\n        array[particle * FLOATS_PER_VEC4],\n        array[particle * FLOATS_PER_VEC4 + 1],\n        array[particle * FLOATS_PER_VEC4 + 2],\n      ];\n\n      assert(\n        x !== undefined && y !== undefined && z !== undefined,\n        `particle ${particle} is missing from the readback`,\n      );\n\n      vectors.push([x, y, z]);\n    }\n\n    return vectors;\n  }\n}\n\nfunction allocate(particles: Particles): Buffers {\n  const count = particles.count;\n  const positionAttribute = buffer.vector(particles.positions);\n  const velocityAttribute = buffer.vector(particles.velocities);\n  const accelerationAttribute = buffer.zeros(count);\n\n  return {\n    count,\n    positionAttribute,\n    velocityAttribute,\n    positions: bind(positionAttribute, count),\n    velocities: bind(velocityAttribute, count),\n    accelerations: bind(accelerationAttribute, count),\n  };\n}\n\nnamespace pass {\n  export function accelerate(model: GpuModel, buffers: Buffers) {\n    const particles: GpuParticles = {\n      count: buffers.count,\n      position: (index) => buffers.positions.element(index).xyz,\n      velocity: (index) => buffers.velocities.element(index).xyz,\n    };\n\n    return Fn(() => {\n      buffers.accelerations\n        .element(instanceIndex)\n        .assign(vec4(model.acceleration({ particles, index: instanceIndex }), 0));\n    })().compute(buffers.count);\n  }\n\n  export function integrate(integrator: Integrator, buffers: Buffers, seconds: SecondsBuffer) {\n    return Fn(() => {\n      const particle = {\n        position: buffers.positions.element(instanceIndex).xyz.toVar(),\n        velocity: buffers.velocities.element(instanceIndex).xyz.toVar(),\n      };\n      const next = integrator.gpu.step({\n        particle,\n        acceleration: buffers.accelerations.element(instanceIndex).xyz,\n        seconds,\n      });\n\n      buffers.positions.element(instanceIndex).assign(vec4(next.position, 0));\n      buffers.velocities.element(instanceIndex).assign(vec4(next.velocity, 0));\n    })().compute(buffers.count);\n  }\n}\n\nfunction executable(\n  renderer: WebGPURenderer,\n  buffers: Buffers,\n  seconds: SecondsBuffer,\n  accelerate: ComputePass,\n  integrate: ComputePass,\n): Executable {\n  let dispatched = false;\n\n  async function latestBuffer(attribute: StorageBufferAttribute): Promise<ArrayBufferLike> {\n    return dispatched ? renderer.getArrayBufferAsync(attribute) : attribute.array.buffer;\n  }\n\n  return {\n    step(time: number): void {\n      // Dispatching over a zero-sized storage buffer is a WebGPU validation error.\n      if (buffers.count === 0) {\n        return;\n      }\n\n      seconds.value = time;\n      renderer.compute([accelerate, integrate]);\n      dispatched = true;\n    },\n    async snapshot(): Promise<Particles> {\n      const [positionBuffer, velocityBuffer] = await Promise.all([\n        latestBuffer(buffers.positionAttribute),\n        latestBuffer(buffers.velocityAttribute),\n      ]);\n\n      return {\n        count: buffers.count,\n        positions: buffer.decode(positionBuffer, buffers.count),\n        velocities: buffer.decode(velocityBuffer, buffers.count),\n      };\n    },\n  };\n}\n\nclass SharedRenderer {\n  private renderer: Promise<WebGPURenderer> | undefined;\n\n  constructor(private readonly device: Device | undefined) {}\n\n  acquire(): Promise<WebGPURenderer> {\n    this.renderer ??= this.initialize();\n    return this.renderer;\n  }\n\n  private async initialize(): Promise<WebGPURenderer> {\n    const renderer = new WebGPURenderer({ forceWebGL: false, device: this.device });\n    await renderer.init();\n    return renderer;\n  }\n}\n\nexport function createGpuBackend({ device }: GpuBackendOptions = {}): Backend {\n  const shared = new SharedRenderer(device);\n\n  return {\n    async compile({ particles, model, integrator }: CompileOptions): Promise<Executable> {\n      const gpuModel = model.gpu;\n      assert(gpuModel !== undefined, \"the model has no gpu implementation\");\n\n      const buffers = allocate(particles);\n      const seconds = secondsBuffer();\n\n      const accelerate = pass.accelerate(gpuModel, buffers);\n      const integrate = pass.integrate(integrator, buffers, seconds);\n\n      return executable(await shared.acquire(), buffers, seconds, accelerate, integrate);\n    },\n  };\n}\n"]}

package/dist/backend/index.d.ts

@@ -0,0 +1,14 @@
+import type { Backend, GpuBackendOptions } from "../types.js";
+/**
+ * Executes a model and integrator over a swarm's state.
+ */
+export declare namespace backend {
+    /**
+     * A backend for running swarm simulations on the CPU.
+     */
+    function cpu(): Backend;
+    /**
+     * A backend for running swarm simulations on the GPU using TSL.
+     */
+    function gpu(options?: GpuBackendOptions): Backend;
+}

package/dist/backend/index.js

@@ -0,0 +1,23 @@
+import { createCpuBackend } from "../backend/cpu.js";
+import { createGpuBackend } from "../backend/gpu.js";
+/**
+ * Executes a model and integrator over a swarm's state.
+ */
+export var backend;
+(function (backend) {
+    /**
+     * A backend for running swarm simulations on the CPU.
+     */
+    function cpu() {
+        return createCpuBackend();
+    }
+    backend.cpu = cpu;
+    /**
+     * A backend for running swarm simulations on the GPU using TSL.
+     */
+    function gpu(options = {}) {
+        return createGpuBackend(options);
+    }
+    backend.gpu = gpu;
+})(backend || (backend = {}));
+//# sourceMappingURL=index.js.map

package/dist/backend/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/backend/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGpD;;GAEG;AACH,MAAM,KAAW,OAAO,CAcvB;AAdD,WAAiB,OAAO;IACtB;;OAEG;IACH,SAAgB,GAAG;QACjB,OAAO,gBAAgB,EAAE,CAAC;IAC5B,CAAC;IAFe,WAAG,MAElB,CAAA;IAED;;OAEG;IACH,SAAgB,GAAG,CAAC,UAA6B,EAAE;QACjD,OAAO,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;IAFe,WAAG,MAElB,CAAA;AACH,CAAC,EAdgB,OAAO,KAAP,OAAO,QAcvB","sourcesContent":["import { createCpuBackend } from \"@/backend/cpu.js\";\nimport { createGpuBackend } from \"@/backend/gpu.js\";\nimport type { Backend, GpuBackendOptions } from \"@/types.js\";\n\n/**\n * Executes a model and integrator over a swarm's state.\n */\nexport namespace backend {\n  /**\n   * A backend for running swarm simulations on the CPU.\n   */\n  export function cpu(): Backend {\n    return createCpuBackend();\n  }\n\n  /**\n   * A backend for running swarm simulations on the GPU using TSL.\n   */\n  export function gpu(options: GpuBackendOptions = {}): Backend {\n    return createGpuBackend(options);\n  }\n}\n"]}

package/dist/device.d.ts

@@ -0,0 +1,11 @@
+import type { Device } from "./types.js";
+/**
+ * Acquires the devices a backend runs on.
+ */
+export declare namespace device {
+    /**
+     * Acquires a WebGPU device, or `undefined` when this browser has no GPU to
+     * run on or an adapter that would rasterize on the CPU.
+     */
+    function gpu(): Promise<Device | undefined>;
+}

package/dist/device.js

@@ -0,0 +1,66 @@
+// Adapter names that indicate that the browser is rasterizing WebGPU on the CPU.
+// These devices are slower than the CPU backend, so we assume it's the same as no device.
+const SOFTWARE_ADAPTERS = ["basic render driver", "lavapipe", "llvmpipe", "software", "swiftshader", "warp"];
+function navigatorGpu() {
+    if (typeof navigator === "undefined") {
+        return undefined;
+    }
+    return navigator.gpu;
+}
+async function gpuAdapter() {
+    const gpu = navigatorGpu();
+    if (gpu === undefined) {
+        return undefined;
+    }
+    let adapter;
+    try {
+        adapter = await gpu.requestAdapter({ powerPreference: "high-performance" });
+    }
+    catch {
+        return undefined;
+    }
+    if (adapter === null || adapter.info.isFallbackAdapter) {
+        return undefined;
+    }
+    return adapter;
+}
+function isSoftwareAdapter(adapter) {
+    // Browsers fill these in unevenly, so every field the adapter does report is
+    // searched for a known software rasterizer.
+    const { vendor, architecture, device, description } = adapter.info;
+    const reported = [vendor, architecture, device, description].join(" ").toLowerCase();
+    return SOFTWARE_ADAPTERS.some((name) => reported.includes(name));
+}
+async function hardwareAdapter() {
+    const adapter = await gpuAdapter();
+    if (adapter === undefined || isSoftwareAdapter(adapter)) {
+        return undefined;
+    }
+    return adapter;
+}
+/**
+ * Acquires the devices a backend runs on.
+ */
+export var device;
+(function (device) {
+    /**
+     * Acquires a WebGPU device, or `undefined` when this browser has no GPU to
+     * run on or an adapter that would rasterize on the CPU.
+     */
+    async function gpu() {
+        const adapter = await hardwareAdapter();
+        if (adapter === undefined) {
+            return undefined;
+        }
+        try {
+            // Every feature the adapter supports is requested to avoid putting
+            // the renderer in compatibility mode.
+            return await adapter.requestDevice({ requiredFeatures: [...adapter.features] });
+        }
+        catch {
+            return undefined;
+        }
+    }
+    device.gpu = gpu;
+})(device || (device = {}));
+//# sourceMappingURL=device.js.map

package/dist/device.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"device.js","sourceRoot":"","sources":["../src/device.ts"],"names":[],"mappings":"AAEA,iFAAiF;AACjF,0FAA0F;AAC1F,MAAM,iBAAiB,GAAG,CAAC,qBAAqB,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,CAAC,CAAC;AAE7G,SAAS,YAAY;IACnB,IAAI,OAAO,SAAS,KAAK,WAAW,EAAE,CAAC;QACrC,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,SAAS,CAAC,GAAG,CAAC;AACvB,CAAC;AAED,KAAK,UAAU,UAAU;IACvB,MAAM,GAAG,GAAG,YAAY,EAAE,CAAC;IAC3B,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,OAA0B,CAAC;IAC/B,IAAI,CAAC;QACH,OAAO,GAAG,MAAM,GAAG,CAAC,cAAc,CAAC,EAAE,eAAe,EAAE,kBAAkB,EAAE,CAAC,CAAC;IAC9E,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACvD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAS,iBAAiB,CAAC,OAAmB;IAC5C,6EAA6E;IAC7E,4CAA4C;IAC5C,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IACnE,MAAM,QAAQ,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;IACrF,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;AACnE,CAAC;AAED,KAAK,UAAU,eAAe;IAC5B,MAAM,OAAO,GAAG,MAAM,UAAU,EAAE,CAAC;IAEnC,IAAI,OAAO,KAAK,SAAS,IAAI,iBAAiB,CAAC,OAAO,CAAC,EAAE,CAAC;QACxD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;GAEG;AACH,MAAM,KAAW,MAAM,CAmBtB;AAnBD,WAAiB,MAAM;IACrB;;;OAGG;IACI,KAAK,UAAU,GAAG;QACvB,MAAM,OAAO,GAAG,MAAM,eAAe,EAAE,CAAC;QACxC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,IAAI,CAAC;YACH,mEAAmE;YACnE,sCAAsC;YACtC,OAAO,MAAM,OAAO,CAAC,aAAa,CAAC,EAAE,gBAAgB,EAAE,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAqB,EAAE,CAAC,CAAC;QACtG,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IAbqB,UAAG,MAaxB,CAAA;AACH,CAAC,EAnBgB,MAAM,KAAN,MAAM,QAmBtB","sourcesContent":["import type { Device } from \"@/types.js\";\n\n// Adapter names that indicate that the browser is rasterizing WebGPU on the CPU.\n// These devices are slower than the CPU backend, so we assume it's the same as no device.\nconst SOFTWARE_ADAPTERS = [\"basic render driver\", \"lavapipe\", \"llvmpipe\", \"software\", \"swiftshader\", \"warp\"];\n\nfunction navigatorGpu(): GPU | undefined {\n  if (typeof navigator === \"undefined\") {\n    return undefined;\n  }\n  return navigator.gpu;\n}\n\nasync function gpuAdapter(): Promise<GPUAdapter | undefined> {\n  const gpu = navigatorGpu();\n  if (gpu === undefined) {\n    return undefined;\n  }\n\n  let adapter: GPUAdapter | null;\n  try {\n    adapter = await gpu.requestAdapter({ powerPreference: \"high-performance\" });\n  } catch {\n    return undefined;\n  }\n\n  if (adapter === null || adapter.info.isFallbackAdapter) {\n    return undefined;\n  }\n\n  return adapter;\n}\n\nfunction isSoftwareAdapter(adapter: GPUAdapter): boolean {\n  // Browsers fill these in unevenly, so every field the adapter does report is\n  // searched for a known software rasterizer.\n  const { vendor, architecture, device, description } = adapter.info;\n  const reported = [vendor, architecture, device, description].join(\" \").toLowerCase();\n  return SOFTWARE_ADAPTERS.some((name) => reported.includes(name));\n}\n\nasync function hardwareAdapter(): Promise<GPUAdapter | undefined> {\n  const adapter = await gpuAdapter();\n\n  if (adapter === undefined || isSoftwareAdapter(adapter)) {\n    return undefined;\n  }\n\n  return adapter;\n}\n\n/**\n * Acquires the devices a backend runs on.\n */\nexport namespace device {\n  /**\n   * Acquires a WebGPU device, or `undefined` when this browser has no GPU to\n   * run on or an adapter that would rasterize on the CPU.\n   */\n  export async function gpu(): Promise<Device | undefined> {\n    const adapter = await hardwareAdapter();\n    if (adapter === undefined) {\n      return undefined;\n    }\n\n    try {\n      // Every feature the adapter supports is requested to avoid putting\n      // the renderer in compatibility mode.\n      return await adapter.requestDevice({ requiredFeatures: [...adapter.features] as GPUFeatureName[] });\n    } catch {\n      return undefined;\n    }\n  }\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import { backend } from "./backend/index.js";
+import { device } from "./device.js";
+import { initializer } from "./initializer/index.js";
+import { integrator } from "./integrator/index.js";
+import { model } from "./model/index.js";
+import { swarm } from "./swarm.js";
+export type { AdvanceOptions, Backend, CompileOptions, Connection, CpuIntegrator, CpuIntegratorOptions, CpuModel, Device, ElasticNetworkOptions, Executable, FixedInitializerOptions, GpuBackendOptions, GpuIntegrator, GpuIntegratorOptions, GpuModel, GpuModelOptions, GpuParticle, GpuParticles, Initializer, Integrator, Model, ModelValidationContext, Particles, Swarm, SwarmOptions, SwarmState, Vector, } from "./types.js";
+/**
+ * The library's public namespace.
+ */
+export declare const gloop: {
+    readonly swarm: typeof swarm;
+    readonly initializer: typeof initializer;
+    readonly model: typeof model;
+    readonly integrator: typeof integrator;
+    readonly backend: typeof backend;
+    readonly device: typeof device;
+};

package/dist/index.js

@@ -0,0 +1,18 @@
+import { backend } from "./backend/index.js";
+import { device } from "./device.js";
+import { initializer } from "./initializer/index.js";
+import { integrator } from "./integrator/index.js";
+import { model } from "./model/index.js";
+import { swarm } from "./swarm.js";
+/**
+ * The library's public namespace.
+ */
+export const gloop = {
+    swarm,
+    initializer,
+    model,
+    integrator,
+    backend,
+    device,
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAgCnC;;GAEG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,KAAK;IACL,WAAW;IACX,KAAK;IACL,UAAU;IACV,OAAO;IACP,MAAM;CACE,CAAC","sourcesContent":["import { backend } from \"@/backend/index.js\";\nimport { device } from \"@/device.js\";\nimport { initializer } from \"@/initializer/index.js\";\nimport { integrator } from \"@/integrator/index.js\";\nimport { model } from \"@/model/index.js\";\nimport { swarm } from \"@/swarm.js\";\n\nexport type {\n  AdvanceOptions,\n  Backend,\n  CompileOptions,\n  Connection,\n  CpuIntegrator,\n  CpuIntegratorOptions,\n  CpuModel,\n  Device,\n  ElasticNetworkOptions,\n  Executable,\n  FixedInitializerOptions,\n  GpuBackendOptions,\n  GpuIntegrator,\n  GpuIntegratorOptions,\n  GpuModel,\n  GpuModelOptions,\n  GpuParticle,\n  GpuParticles,\n  Initializer,\n  Integrator,\n  Model,\n  ModelValidationContext,\n  Particles,\n  Swarm,\n  SwarmOptions,\n  SwarmState,\n  Vector,\n} from \"@/types.js\";\n\n/**\n * The library's public namespace.\n */\nexport const gloop = {\n  swarm,\n  initializer,\n  model,\n  integrator,\n  backend,\n  device,\n} as const;\n"]}

package/dist/initializer/fixed.d.ts

@@ -0,0 +1,2 @@
+import type { FixedInitializerOptions, Initializer } from "../types.js";
+export declare function fixed(options: FixedInitializerOptions): Initializer;

package/dist/initializer/fixed.js

@@ -0,0 +1,12 @@
+export function fixed(options) {
+    return {
+        initialize(particleCount) {
+            return {
+                count: particleCount,
+                positions: options.positions.slice(0, particleCount),
+                velocities: options.velocities.slice(0, particleCount),
+            };
+        },
+    };
+}
+//# sourceMappingURL=fixed.js.map

package/dist/initializer/fixed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed.js","sourceRoot":"","sources":["../../src/initializer/fixed.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,KAAK,CAAC,OAAgC;IACpD,OAAO;QACL,UAAU,CAAC,aAAqB;YAC9B,OAAO;gBACL,KAAK,EAAE,aAAa;gBACpB,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,aAAa,CAAC;gBACpD,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,aAAa,CAAC;aACvD,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import type { FixedInitializerOptions, Initializer, Particles } from \"@/types.js\";\n\nexport function fixed(options: FixedInitializerOptions): Initializer {\n  return {\n    initialize(particleCount: number): Particles {\n      return {\n        count: particleCount,\n        positions: options.positions.slice(0, particleCount),\n        velocities: options.velocities.slice(0, particleCount),\n      };\n    },\n  };\n}\n"]}

package/dist/initializer/index.d.ts

@@ -0,0 +1,14 @@
+import type { FixedInitializerOptions, Initializer } from "../types.js";
+/**
+ * Supplies the starting positions and velocities of a swarm's particles.
+ */
+export declare namespace initializer {
+    /**
+     * Uses caller-supplied positions and velocities to initialize the swarm.
+     */
+    function fixed(options: FixedInitializerOptions): Initializer;
+    /**
+     * Scatters particles at rest through the unit cube centered on the origin.
+     */
+    function random(): Initializer;
+}

package/dist/initializer/index.js

@@ -0,0 +1,23 @@
+import { fixed as createFixed } from "../initializer/fixed.js";
+import { random as createRandom } from "../initializer/random.js";
+/**
+ * Supplies the starting positions and velocities of a swarm's particles.
+ */
+export var initializer;
+(function (initializer) {
+    /**
+     * Uses caller-supplied positions and velocities to initialize the swarm.
+     */
+    function fixed(options) {
+        return createFixed(options);
+    }
+    initializer.fixed = fixed;
+    /**
+     * Scatters particles at rest through the unit cube centered on the origin.
+     */
+    function random() {
+        return createRandom();
+    }
+    initializer.random = random;
+})(initializer || (initializer = {}));
+//# sourceMappingURL=index.js.map

package/dist/initializer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/initializer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,MAAM,IAAI,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAGjE;;GAEG;AACH,MAAM,KAAW,WAAW,CAc3B;AAdD,WAAiB,WAAW;IAC1B;;OAEG;IACH,SAAgB,KAAK,CAAC,OAAgC;QACpD,OAAO,WAAW,CAAC,OAAO,CAAC,CAAC;IAC9B,CAAC;IAFe,iBAAK,QAEpB,CAAA;IAED;;OAEG;IACH,SAAgB,MAAM;QACpB,OAAO,YAAY,EAAE,CAAC;IACxB,CAAC;IAFe,kBAAM,SAErB,CAAA;AACH,CAAC,EAdgB,WAAW,KAAX,WAAW,QAc3B","sourcesContent":["import { fixed as createFixed } from \"@/initializer/fixed.js\";\nimport { random as createRandom } from \"@/initializer/random.js\";\nimport type { FixedInitializerOptions, Initializer } from \"@/types.js\";\n\n/**\n * Supplies the starting positions and velocities of a swarm's particles.\n */\nexport namespace initializer {\n  /**\n   * Uses caller-supplied positions and velocities to initialize the swarm.\n   */\n  export function fixed(options: FixedInitializerOptions): Initializer {\n    return createFixed(options);\n  }\n\n  /**\n   * Scatters particles at rest through the unit cube centered on the origin.\n   */\n  export function random(): Initializer {\n    return createRandom();\n  }\n}\n"]}

package/dist/initializer/random.d.ts

@@ -0,0 +1,2 @@
+import type { Initializer } from "../types.js";
+export declare function random(): Initializer;

package/dist/initializer/random.js

@@ -0,0 +1,16 @@
+const ZERO = [0, 0, 0];
+function randomPosition() {
+    return [Math.random() - 0.5, Math.random() - 0.5, Math.random() - 0.5];
+}
+export function random() {
+    return {
+        initialize(particleCount) {
+            return {
+                count: particleCount,
+                positions: Array.from({ length: particleCount }, randomPosition),
+                velocities: Array.from({ length: particleCount }, () => ZERO),
+            };
+        },
+    };
+}
+//# sourceMappingURL=random.js.map

package/dist/initializer/random.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.js","sourceRoot":"","sources":["../../src/initializer/random.ts"],"names":[],"mappings":"AAEA,MAAM,IAAI,GAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAE/B,SAAS,cAAc;IACrB,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,EAAE,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,EAAE,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC;AACzE,CAAC;AAED,MAAM,UAAU,MAAM;IACpB,OAAO;QACL,UAAU,CAAC,aAAqB;YAC9B,OAAO;gBACL,KAAK,EAAE,aAAa;gBACpB,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,aAAa,EAAE,EAAE,cAAc,CAAC;gBAChE,UAAU,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,aAAa,EAAE,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC;aAC9D,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import type { Initializer, Particles, Vector } from \"@/types.js\";\n\nconst ZERO: Vector = [0, 0, 0];\n\nfunction randomPosition(): Vector {\n  return [Math.random() - 0.5, Math.random() - 0.5, Math.random() - 0.5];\n}\n\nexport function random(): Initializer {\n  return {\n    initialize(particleCount: number): Particles {\n      return {\n        count: particleCount,\n        positions: Array.from({ length: particleCount }, randomPosition),\n        velocities: Array.from({ length: particleCount }, () => ZERO),\n      };\n    },\n  };\n}\n"]}

package/dist/integrator/euler.d.ts

@@ -0,0 +1,2 @@
+import type { Integrator } from "../types.js";
+export declare function explicitEuler(): Integrator;