bevy-ts 0.1.0-alpha.1 → 0.1.0-alpha.10

package/bin/bevy-ts.js

@@ -1,10 +1,18 @@
 #!/usr/bin/env node
 // Runs the precompiled engine binary from the platform package npm installed alongside this one
 // (as esbuild and Biome ship), so `npx bevy-ts dev src/game.ts` needs no Rust toolchain.
-// BEVY_TS_BINARY overrides the binary, for engine development.
+// BEVY_TS_BINARY overrides the binary, for engine development. `new` and `examples` run here, in
+// Node, with no engine.
 import { spawn } from "node:child_process";
+import { create, examples } from "./examples.js";
 import { binary } from "./resolve.js";
 
+// exitCode, not exit(): stdout to a pipe is written asynchronously and must drain first.
+const [command, ...rest] = process.argv.slice(2);
+if (command === "new") process.exitCode = create(rest);
+else if (command === "examples") process.exitCode = examples(rest);
+else runEngine();
+
 function binaryOrExit() {
   try {
     return binary();
@@ -14,11 +22,13 @@ function binaryOrExit() {
   }
 }
 
-// Forward signals so stopping the launcher stops the engine too.
-const child = spawn(binaryOrExit(), process.argv.slice(2), { stdio: "inherit" });
-for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) process.on(sig, () => child.kill(sig));
-child.on("error", (e) => {
-  console.error(`bevy-ts: ${e.message}`);
-  process.exit(1);
-});
-child.on("exit", (code, signal) => process.exit(code ?? (signal ? 1 : 0)));
+function runEngine() {
+  // Forward signals so stopping the launcher stops the engine too.
+  const child = spawn(binaryOrExit(), process.argv.slice(2), { stdio: "inherit" });
+  for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) process.on(sig, () => child.kill(sig));
+  child.on("error", (e) => {
+    console.error(`bevy-ts: ${e.message}`);
+    process.exit(1);
+  });
+  child.on("exit", (code, signal) => process.exit(code ?? (signal ? 1 : 0)));
+}

package/bin/examples.js

@@ -0,0 +1,141 @@
+// `bevy-ts examples` and `bevy-ts new`: the launcher's own commands. They read the examples this
+// package ships (copied in at pack time by scripts/sync-examples.mjs) and never start the engine.
+import { spawnSync } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = fileURLToPath(new URL("../examples/", import.meta.url));
+const version = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+// What `new` leaves out of the copy: the metadata, not the game.
+const META = ["example.json", "thumbnail.png"];
+
+/** The shipped examples, in the order to show them: `cube` first, then by id. */
+export function list() {
+  if (!existsSync(root)) return [];
+  const out = [];
+  for (const name of readdirSync(root)) {
+    const file = `${root}${name}/example.json`;
+    if (!existsSync(file)) continue;
+    const { id, title, description, entry } = JSON.parse(readFileSync(file, "utf8"));
+    const e = { id, title, description, entry };
+    if (existsSync(`${root}${name}/thumbnail.png`)) e.thumbnail = `${root}${name}/thumbnail.png`;
+    e.dir = `${root}${name}`;
+    out.push(e);
+  }
+  return out.sort((a, b) => (a.id === "cube" ? -1 : b.id === "cube" ? 1 : a.id < b.id ? -1 : 1));
+}
+
+function refuse(msg, code = 1) {
+  console.error(`bevy-ts: ${msg}`);
+  return code;
+}
+
+export function examples(args) {
+  const all = list().map(({ dir, ...e }) => e);
+  if (args.includes("--json")) {
+    process.stdout.write(`${JSON.stringify({ version, examples: all })}\n`);
+  } else {
+    for (const e of all) console.log(`${e.id.padEnd(10)} ${e.title}: ${e.description}`);
+  }
+  return 0;
+}
+
+const NEW_USAGE = "usage: bevy-ts new <dir> [--example <id>] [--no-install] [--json]";
+
+export function create(args) {
+  let dir;
+  let id = "cube";
+  let install = true;
+  let json = false;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--example") {
+      id = args[++i];
+      if (!id || id.startsWith("--")) return refuse(`--example takes an id\n${NEW_USAGE}`, 2);
+    } else if (a === "--no-install") install = false;
+    else if (a === "--json") json = true;
+    else if (a.startsWith("--")) return refuse(`unknown option ${a}\n${NEW_USAGE}`, 2);
+    else if (dir === undefined) dir = a;
+    else return refuse(`unexpected argument ${a}\n${NEW_USAGE}`, 2);
+  }
+  if (dir === undefined) return refuse(`missing <dir>\n${NEW_USAGE}`, 2);
+
+  // Everything is checked before the first write, so a refusal writes nothing.
+  const all = list();
+  const example = all.find((e) => e.id === id);
+  if (!example) return refuse(`no example "${id}"; there are: ${all.map((e) => e.id).join(", ")}`);
+  const target = resolve(dir);
+  if (existsSync(target)) {
+    if (!statSync(target).isDirectory()) return refuse(`${target} is a file`);
+    if (readdirSync(target).length) return refuse(`${target} is not empty; bevy-ts new makes a project only in an empty or missing directory`);
+  }
+
+  try {
+    mkdirSync(target, { recursive: true });
+    for (const f of readdirSync(example.dir)) {
+      if (!META.includes(f)) cpSync(`${example.dir}/${f}`, `${target}/${f}`, { recursive: true });
+    }
+    const name = basename(target).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[._-]+/, "") || "game";
+    const pkg = {
+      name,
+      private: true,
+      type: "module",
+      scripts: { dev: `bevy-ts dev ${example.entry}` },
+      devDependencies: { "bevy-ts": version },
+    };
+    // The examples' compiler options, resolving bevy-ts from node_modules instead of the checkout.
+    const tsconfig = {
+      compilerOptions: {
+        target: "es2023",
+        module: "esnext",
+        moduleResolution: "bundler",
+        strict: true,
+        noEmit: true,
+        verbatimModuleSyntax: true,
+        jsx: "react-jsx",
+        jsxImportSource: "bevy-ts",
+        allowImportingTsExtensions: true,
+      },
+      include: ["src", ".bevy-ts/types"],
+    };
+    writeFileSync(`${target}/package.json`, `${JSON.stringify(pkg, null, 2)}\n`);
+    writeFileSync(`${target}/tsconfig.json`, `${JSON.stringify(tsconfig, null, 2)}\n`);
+    writeFileSync(`${target}/.gitignore`, "node_modules/\n.bevy-ts/\n");
+  } catch (e) {
+    return refuse(e.message);
+  }
+
+  const pm = packageManager();
+  const installed = install ? runInstall(pm, target) : false;
+  if (json) {
+    process.stdout.write(`${JSON.stringify({ dir: target, entry: example.entry, example: id, installed })}\n`);
+  } else {
+    console.log(`Made ${target} from ${id}${install && !installed ? "; the install failed" : ""}.`);
+    const steps = [`cd ${shellQuote(dir)}`, ...(installed ? [] : [`${pm} install`]), `npx bevy-ts dev ${example.entry}`];
+    console.log(`  ${steps.join(" && ")}`);
+  }
+  return install && !installed ? 1 : 0;
+}
+
+/** The package manager that ran bevy-ts (npm, pnpm, yarn or bun), npm otherwise. */
+function packageManager() {
+  const agent = (process.env.npm_config_user_agent ?? "").split("/")[0];
+  return ["npm", "pnpm", "yarn", "bun"].includes(agent) ? agent : "npm";
+}
+
+/** The path as it pastes into a POSIX shell: single-quoted when it holds anything but safe characters. */
+function shellQuote(p) {
+  return /^[\w@%+=:,./-]+$/.test(p) ? p : `'${p.replaceAll("'", "'\\''")}'`;
+}
+
+/** Installs with `pm` in `dir`, its output on stderr. */
+function runInstall(pm, dir) {
+  console.error(`bevy-ts: ${pm} install in ${dir}`);
+  const r = spawnSync(pm, ["install"], { cwd: dir, stdio: ["ignore", 2, 2], shell: process.platform === "win32" });
+  if (r.error || r.status !== 0) {
+    console.error(`bevy-ts: ${pm} install failed${r.error ? `: ${r.error.message}` : ""}; the project is in place, run it again there`);
+    return false;
+  }
+  return true;
+}

package/examples/arena/assets/levels/arena.bsn

@@ -0,0 +1,18 @@
+// The arena: where things are. What an enemy is lives in src/enemy.tsx.
+
+#EnemyA
+@enemy::Enemy
+Transform { translation: Vec3 { x: -3.0, z: -4.0 } }
+--
+#EnemyB
+@enemy::Enemy { @hp: 250.0 }
+Transform { translation: Vec3 { x: 3.0, z: -4.0 } }
+--
+// Two copies of one room, each with its guard.
+#RoomA
+:"levels/room.bsn"
+Transform { translation: Vec3 { x: -12.0, z: -12.0 } }
+--
+#RoomB
+:"levels/room.bsn"
+Transform { translation: Vec3 { x: 12.0, z: -12.0 } }

package/examples/arena/assets/levels/room.bsn

@@ -0,0 +1,8 @@
+// A room, placed twice by arena.bsn: its guard is an enemy too.
+#Room
+Transform
+Children [
+    #Guard
+    @enemy::Enemy { @hp: 50.0 }
+    Transform { translation: Vec3 { z: -16.0 } }
+]

package/examples/arena/assets/models/crate.gltf

@@ -0,0 +1,103 @@
+{
+  "accessors": [
+    {
+      "bufferView": 0,
+      "componentType": 5126,
+      "count": 24,
+      "max": [
+        0.5,
+        0.5,
+        0.5
+      ],
+      "min": [
+        -0.5,
+        -0.5,
+        -0.5
+      ],
+      "type": "VEC3"
+    },
+    {
+      "bufferView": 1,
+      "componentType": 5126,
+      "count": 24,
+      "type": "VEC3"
+    },
+    {
+      "bufferView": 2,
+      "componentType": 5123,
+      "count": 36,
+      "type": "SCALAR"
+    }
+  ],
+  "asset": {
+    "generator": "bevy-ts-viewport tests/assets.rs",
+    "version": "2.0"
+  },
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteLength": 288,
+      "byteOffset": 0
+    },
+    {
+      "buffer": 0,
+      "byteLength": 288,
+      "byteOffset": 288
+    },
+    {
+      "buffer": 0,
+      "byteLength": 72,
+      "byteOffset": 576
+    }
+  ],
+  "buffers": [
+    {
+      "byteLength": 648,
+      "uri": "data:application/octet-stream;base64,AAAAPwAAAL8AAAC/AAAAPwAAAD8AAAC/AAAAPwAAAD8AAAA/AAAAPwAAAL8AAAA/AAAAvwAAAL8AAAA/AAAAvwAAAD8AAAA/AAAAvwAAAD8AAAC/AAAAvwAAAL8AAAC/AAAAvwAAAD8AAAC/AAAAvwAAAD8AAAA/AAAAPwAAAD8AAAA/AAAAPwAAAD8AAAC/AAAAvwAAAL8AAAA/AAAAvwAAAL8AAAC/AAAAPwAAAL8AAAC/AAAAPwAAAL8AAAA/AAAAvwAAAL8AAAA/AAAAPwAAAL8AAAA/AAAAPwAAAD8AAAA/AAAAvwAAAD8AAAA/AAAAPwAAAL8AAAC/AAAAvwAAAL8AAAC/AAAAvwAAAD8AAAC/AAAAPwAAAD8AAAC/AACAPwAAAAAAAAAAAACAPwAAAAAAAAAAAACAPwAAAAAAAAAAAACAPwAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAAAAAAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAAAAAAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/AAAAAAAAAAAAAIC/AAAAAAAAAAAAAIC/AAAAAAAAAAAAAIC/AAAAAAAAAAAAAIC/AAABAAIAAAACAAMABAAFAAYABAAGAAcACAAJAAoACAAKAAsADAANAA4ADAAOAA8AEAARABIAEAASABMAFAAVABYAFAAWABcA"
+    }
+  ],
+  "materials": [
+    {
+      "name": "wood",
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.55,
+          0.36,
+          0.18,
+          1.0
+        ],
+        "metallicFactor": 0.0,
+        "roughnessFactor": 0.8
+      }
+    }
+  ],
+  "meshes": [
+    {
+      "name": "crate",
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 1,
+            "POSITION": 0
+          },
+          "indices": 2,
+          "material": 0
+        }
+      ]
+    }
+  ],
+  "nodes": [
+    {
+      "mesh": 0,
+      "name": "crate"
+    }
+  ],
+  "scene": 0,
+  "scenes": [
+    {
+      "nodes": [
+        0
+      ]
+    }
+  ]
+}

package/examples/arena/example.json

@@ -0,0 +1,6 @@
+{
+  "id": "arena",
+  "title": "Arena",
+  "description": "A player and a HUD in TSX, enemies placed by a level file, and systems that bob, hurt and cull them.",
+  "entry": "src/game.tsx"
+}

package/examples/arena/src/enemy.tsx

@@ -0,0 +1,28 @@
+// What an enemy is: a scene component. Levels place it (assets/levels/arena.bsn writes
+// `@enemy::Enemy { @hp: 250.0 }`), and TSX can mount it too (`<Enemy at={[0, 0, -6]} />`).
+import { Component, SceneComponent, type f32, type Vec3Like } from "bevy-ts";
+import { Transform } from "bevy-ts/bevy";
+
+export class Health extends Component {
+  hp: f32 = 100;
+  max: f32 = 100;
+}
+/** Marks enemies, for the systems that move and cull them. */
+export class Foe extends Component {}
+
+export class Enemy extends SceneComponent {
+  static scene({ hp = 100, at = [0, 0, 0] }: { hp?: f32; at?: Vec3Like }) {
+    return (
+      <entity name="enemy">
+        <Transform translation={at} />
+        <Health initialHp={hp} max={hp} />
+        <Foe />
+        <mesh shape="cuboid" size={[1, 1, 1]} color="#cc3333" />
+        <entity key="eye">
+          <Transform translation={[0, 0.6, 0.5]} />
+          <mesh shape="sphere" radius={0.15} color="#ffffff" />
+        </entity>
+      </entity>
+    );
+  }
+}

package/examples/arena/src/game.tsx

@@ -0,0 +1,57 @@
+// The arena: a player, a HUD and the sun in TSX, the enemies placed by assets/levels/arena.bsn, a camera, and
+// three systems that play. `bevy-ts dev src/game.tsx`.
+import { app, type Commands, type Entity, type Local, type Mut, type Query, ref, type Res, Startup, Time, Transform, type u32, Update, type With, type Without } from "bevy-ts";
+import { DirectionalLight } from "bevy-ts/bevy";
+import { Foe, Health } from "./enemy.tsx";
+import { Hud } from "./hud.tsx";
+import { Player, PlayerUnit } from "./player.tsx";
+
+/** The game's camera. It sits where the editor's first view does, so edit mode opens on the same
+ * view. */
+export function stage(commands: Commands) {
+  commands.spawnNative("camera3d", { position: [-6, 5, 10], lookAt: [0, 0, 0] });
+}
+
+/** Every 30 frames, each enemy within 10 units hurts the player by 5. */
+export function damage(
+  clock: Local<{ frames: u32 }>,
+  enemies: Query<[Transform], With<Foe>>,
+  players: Query<[Transform, Mut<Health>], With<Player>>,
+) {
+  clock.frames += 1;
+  if (clock.frames % 30 !== 0) return;
+  players.each((p, h) => {
+    enemies.each((e) => {
+      if (e.translation.distance(p.translation) < 10) h.hp = Math.max(0, h.hp - 5);
+    });
+  });
+}
+
+/** Enemies bob up and down. */
+export function bob(time: Res<Time>, enemies: Query<[Mut<Transform>], [With<Foe>, Without<Player>]>) {
+  enemies.each((t) => {
+    t.translation.y = Math.sin(time.elapsed_secs * 2) * 0.5;
+  });
+}
+
+/** Enemies at no hp are despawned: a reload does not bring them back. */
+export function cull(commands: Commands, enemies: Query<[Entity, Health], With<Foe>>) {
+  enemies.each((e, h) => {
+    if (h.hp <= 0) commands.entity(e).despawn();
+  });
+}
+
+const player = ref();
+app.scene("arena", () => (
+  <>
+    {/* The sun is scene, not a startup's, so edit mode shows the arena lit. At (3, 6, 2), looking at the origin. */}
+    <entity name="sun">
+      <DirectionalLight shadow_maps_enabled />
+      <Transform translation={[3, 6, 2]} rotation={[-0.4341, 0.4107, 0.2323, 0.7674]} />
+    </entity>
+    <PlayerUnit handle={player} />
+    <Hud player={player} />
+  </>
+));
+app.level("levels/arena.bsn");
+app.addSystems(Startup, stage).addSystems(Update, damage, bob, cull);

package/examples/arena/src/hud.tsx

@@ -0,0 +1,12 @@
+// The HUD: no hooks. The text binds the player's Health; the button mounts an enemy.
+import { type NodeRef, px } from "bevy-ts";
+import { Enemy, Health } from "./enemy.tsx";
+
+export const Hud = ({ player }: { player: NodeRef }) => (
+  <node style={{ position: "absolute", top: px(12), left: px(12), padding: px(8), flexDirection: "column", rowGap: px(6) }} background="#00000088">
+    <text key="hp" size={20}>{() => `HP ${Math.ceil(player.get(Health).hp)} / ${player.get(Health).max}`}</text>
+    <button key="spawn" style={{ padding: px(4) }} background="#3366cc" onPointerClick={({ commands, frame }) => commands.mount(<Enemy key={`e${frame}`} at={[0, 0, -6]} />)}>
+      <text>Spawn</text>
+    </button>
+  </node>
+);

package/examples/arena/src/player.tsx

@@ -0,0 +1,14 @@
+import { Component, type NodeRef } from "bevy-ts";
+import { Transform } from "bevy-ts/bevy";
+import { Health } from "./enemy.tsx";
+
+export class Player extends Component {}
+
+export const PlayerUnit = ({ handle }: { handle: NodeRef }) => (
+  <entity name="player" ref={handle}>
+    <Transform translation={[0, 0, 0]} />
+    <Health initialHp={100} max={100} />
+    <Player />
+    <mesh shape="sphere" radius={0.5} color="#3366cc" />
+  </entity>
+);

package/examples/cube/example.json

@@ -0,0 +1,6 @@
+{
+  "id": "cube",
+  "title": "Cube",
+  "description": "One cube bobbing on a sine wave: a scene, a component, a startup system and an update system.",
+  "entry": "src/game.ts"
+}

package/examples/cube/src/cube.tsx

@@ -0,0 +1,19 @@
+// The cube's scene: the cube and the sun, so edit mode shows them before any system runs.
+// game.ts mounts it once `Mover` is defined.
+import { DirectionalLight, Transform } from "bevy-ts/bevy";
+import { Mover } from "./game.ts";
+
+export const Cube = () => (
+  <>
+    {/* At (3, 6, 2), looking at the origin. */}
+    <entity name="sun">
+      <DirectionalLight shadow_maps_enabled />
+      <Transform translation={[3, 6, 2]} rotation={[-0.4341, 0.4107, 0.2323, 0.7674]} />
+    </entity>
+    <entity name="cube">
+      <Transform />
+      <mesh shape="cuboid" size={[1, 1, 1]} color="#ff8800" />
+      <Mover />
+    </entity>
+  </>
+);

package/examples/cube/src/game.ts

@@ -0,0 +1,22 @@
+import { app, Component, type f32, Startup, Time, Transform, Update } from "bevy-ts";
+import type { Commands, Mut, Query, Res } from "bevy-ts";
+import { Cube } from "./cube.tsx";
+
+export class Mover extends Component {
+  speed: f32 = 1;
+  amplitude: f32 = 2;
+}
+
+/** The game's camera; the cube and the sun are the scene's, in cube.tsx. */
+export function scene(commands: Commands) {
+  commands.spawnNative("camera3d", { position: [-3, 3, 6], lookAt: [0, 0, 0] });
+}
+
+export function bob(time: Res<Time>, q: Query<[Mover, Mut<Transform>]>) {
+  q.each((mover, t) => {
+    t.translation.y = Math.sin(time.elapsed_secs * mover.speed) * mover.amplitude;
+  });
+}
+
+app.scene("cube", Cube);
+app.addSystems(Startup, scene).addSystems(Update, bob);

package/examples/cube/src/glow.tsx

@@ -0,0 +1,18 @@
+// The cube example with a script material (bevy-ts/material): its params in TS, its shader in
+// glow.wgsl, no Rust. Run this file as the entry: `bevy-ts dev examples/cube/src/glow.tsx`.
+// Save glow.wgsl and the cube redraws with no reload; change the params and it re-encodes.
+import "./game.ts";
+import { app } from "bevy-ts";
+import { Transform } from "bevy-ts/bevy";
+import { color, f32, material } from "bevy-ts/material";
+import glow from "./glow.wgsl";
+
+export const Glow = material("game::Glow", { params: { color: color, pulse: f32 }, fragment: glow });
+
+app.scene("glow", () => (
+  <entity name="glow">
+    <Transform translation={[2.5, 0, 0]} />
+    <mesh shape="cuboid" size={[1, 1, 1]} />
+    <material kind={Glow} color="#ff8800" pulse={2} />
+  </entity>
+));

package/examples/cube/src/glow.wgsl

@@ -0,0 +1,13 @@
+// game::Glow's fragment shader. bevy-ts appends `params` (a GlowParams with color and pulse)
+// from the schema in glow.tsx, so this file does not declare it.
+import bevy_pbr::render::forward_io::VertexOutput;
+import bevy_pbr::render::mesh_view_bindings::globals;
+
+const FLOOR: f32 = 0.25;
+
+@fragment
+fn fragment(in: VertexOutput) -> @location(0) vec4<f32> {
+    let wave = 0.5 + 0.5 * sin(globals.time * params.pulse);
+    let glow = FLOOR + (1.0 - FLOOR) * wave;
+    return vec4<f32>(params.color.rgb * glow, params.color.a);
+}

package/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference path="./wgsl.d.ts" />
 // Types for `bevy-ts`: the ruled surface (operator, 2026-10-20; docs/research/dx.md). The runtime
 // is built into the engine binary.
 //
@@ -427,6 +428,8 @@ export interface App {
 
 /** Writes a manifest section for a Rust plugin. */
 export declare function section(name: string, value: Uint8Array | string | object): void;
+/** The loading generation's `{ items }` list for a JSON section, for a built-in module's per-generation declarations. */
+export declare function sectionItems(name: string): unknown[];
 /** Decodes UTF-8 bytes. */
 export declare function text(bytes: Uint8Array): string;
 /** A plugin: an exported function taking the app, as Bevy's `fn build(&self, app: &mut App)`. */

package/jsx-runtime.d.ts

@@ -132,6 +132,17 @@ export interface MaterialProps {
   roughness?: number;
   emissive?: string;
   unlit?: boolean;
+  kind?: never;
+}
+
+/**
+ * `<material kind={Glow} color="#f80" pulse={2} />`: a script material from `material()` in
+ * `bevy-ts/material`, with its params by name and its textures as asset paths. Checked against
+ * the kind's schema when the generation loads.
+ */
+export interface ScriptMaterialProps {
+  kind: { readonly name: string };
+  [param: string]: unknown;
 }
 
 type DescElement = Element;
@@ -161,7 +172,7 @@ export declare namespace JSX {
   interface IntrinsicElements {
     entity: EntityProps & KeyAttribute;
     mesh: MeshProps;
-    material: MaterialProps;
+    material: MaterialProps | ScriptMaterialProps;
     node: NodeProps & KeyAttribute;
     button: NodeProps & KeyAttribute;
     text: TextProps & KeyAttribute;

package/material.d.ts

@@ -0,0 +1,61 @@
+// @generated from crates/bevy-ts-material/ts/material.d.ts by scripts/sync-runtime.mjs. Do not edit.
+/** The value a `.wgsl` import gives: the file, by path. Its WGSL stays in the engine. */
+export interface ShaderFile {
+  readonly kind: "shaderFile";
+  readonly path: string;
+}
+
+export type Base = "f32" | "i32" | "u32" | "vec2f" | "vec3f" | "vec4f" | "mat4x4f" | "color";
+export type ParamType = Base | { readonly array: Base; readonly len: number };
+
+export declare const f32: "f32";
+export declare const i32: "i32";
+export declare const u32: "u32";
+export declare const vec2f: "vec2f";
+export declare const vec3f: "vec3f";
+export declare const vec4f: "vec4f";
+export declare const mat4x4f: "mat4x4f";
+/** A `vec4<f32>` in linear RGBA, written as `"#f80"` or sRGB `[r, g, b, a?]`. */
+export declare const color: "color";
+/** A 2D texture with a filtering sampler: `name` and `name_sampler` in WGSL. */
+export declare const texture2d: "texture2d";
+
+/** A fixed array, strided to 16 bytes; scalar and `vec2f` elements read as `.x`/`.xy` of a `vec4`. */
+export declare function array<B extends Base, N extends number>(of: B, len: N): { readonly array: B; readonly len: N };
+
+export type AlphaMode = "opaque" | "blend" | "premultiplied" | "add" | "multiply" | "alphaToCoverage" | { mask: number };
+
+/** A param's value in TS: numbers, number tuples, or a color. */
+export type ParamValue<T extends ParamType> = T extends "f32" | "i32" | "u32"
+  ? number
+  : T extends "vec2f"
+    ? [number, number]
+    : T extends "vec3f"
+      ? [number, number, number]
+      : T extends "vec4f"
+        ? [number, number, number, number]
+        : T extends "mat4x4f"
+          ? number[]
+          : T extends "color"
+            ? string | [number, number, number] | [number, number, number, number]
+            : T extends { array: infer E extends Base }
+              ? ParamValue<E>[]
+              : never;
+
+/** A material kind, what `<material kind={...} />` names. */
+export interface MaterialKind<P extends Record<string, ParamType> = Record<string, ParamType>, T extends Record<string, "texture2d"> = {}> {
+  readonly name: string;
+  /** Types only: the params and textures `<material>` takes for this kind. */
+  readonly __props?: { [K in keyof P]?: ParamValue<P[K]> } & { [K in keyof T]?: string };
+}
+
+/**
+ * Declares a script material: its params, laid out by WGSL's uniform rules in Rust; its textures;
+ * and its shaders, `.wgsl` files imported like modules (`import glow from "./glow.wgsl"`). The WGSL
+ * reads the params as `params.<name>` and each texture as `<name>` with `<name>_sampler`; bevy-ts
+ * appends those declarations, so the file does not declare them.
+ */
+export declare function material<P extends Record<string, ParamType>, T extends Record<string, "texture2d"> = {}>(
+  name: string,
+  decl: { params: P; textures?: T; fragment: ShaderFile; vertex?: ShaderFile; alphaMode?: AlphaMode },
+): MaterialKind<P, T>;