@adobe/data-gpu 0.9.74 → 0.9.76

package/src/material/json/to-definition.ts

@@ -0,0 +1,70 @@
+import { solidDefaults } from "../material-defaults.js";
+import type { MaterialDefinition } from "../material-definition.js";
+import { StressStrainCurve } from "../stress-strain-curve/stress-strain-curve.js";
+import type { PropertiesJson } from "./properties-json.js";
+
+export const toDefinition = (props: PropertiesJson): MaterialDefinition => ({
+    baseColorFactor: [...props.baseColorFactor],
+    emissiveFactor: [...props.emissiveFactor],
+    metallicFactor: props.metallicFactor,
+    roughnessFactor: props.roughnessFactor,
+    irReflectance: props.irReflectance,
+    irEmission: props.irEmission,
+    emissionMode: props.emissionMode,
+    restitution: props.restitution,
+    density: props.density,
+    viscosity: props.viscosity,
+    heatCapacity: props.heatCapacity,
+    thermalConductivity: props.thermalConductivity,
+    friction: props.friction ?? solidDefaults.friction,
+    compliance: props.compliance ?? solidDefaults.compliance,
+    normalScale: props.normalScale ?? solidDefaults.normalScale,
+    occlusionStrength: props.occlusionStrength ?? solidDefaults.occlusionStrength,
+    baseColorUrl: "",
+    metallicRoughnessUrl: "",
+    normalUrl: "",
+    occlusionUrl: "",
+    emissiveUrl: "",
+    stressStrainCurve: StressStrainCurve.create({
+        tensileYieldStrainStress: [...props.stressStrainCurve.tensileYieldStrainStress],
+        tensileFractureStrainStress: [...props.stressStrainCurve.tensileFractureStrainStress],
+        compressiveYieldStrainStress: [...props.stressStrainCurve.compressiveYieldStrainStress],
+        compressiveFractureStrainStress: [...props.stressStrainCurve.compressiveFractureStrainStress],
+    }),
+});
+
+/** Accept legacy JSON field names (baseColor, metallic, specificHeatCapacity, …). */
+export const toDefinitionFromUnknown = (props: Record<string, unknown>): MaterialDefinition | null => {
+    const baseColorFactor = props.baseColorFactor ?? props.baseColor;
+    const emissiveFactor = props.emissiveFactor ?? props.emissionRgb;
+    const metallicFactor = props.metallicFactor ?? props.metallic;
+    const roughnessFactor = props.roughnessFactor ?? props.roughness;
+    const heatCapacity = props.heatCapacity ?? props.specificHeatCapacity;
+    if (
+        !Array.isArray(baseColorFactor) || baseColorFactor.length !== 4
+        || !Array.isArray(emissiveFactor) || emissiveFactor.length !== 3
+        || typeof metallicFactor !== "number"
+        || typeof roughnessFactor !== "number"
+        || typeof heatCapacity !== "number"
+        || typeof props.stressStrainCurve !== "object"
+    ) {
+        return null;
+    }
+    return toDefinition({
+        baseColorFactor: baseColorFactor as unknown as PropertiesJson["baseColorFactor"],
+        emissiveFactor: emissiveFactor as unknown as PropertiesJson["emissiveFactor"],
+        metallicFactor: metallicFactor as number,
+        roughnessFactor: roughnessFactor as number,
+        irReflectance: (props.irReflectance as number) ?? 0,
+        irEmission: (props.irEmission as number) ?? 0,
+        emissionMode: (props.emissionMode as number) ?? 0,
+        density: props.density as number,
+        viscosity: (props.viscosity as number) ?? 0,
+        heatCapacity: heatCapacity as number,
+        thermalConductivity: (props.thermalConductivity as number) ?? 0,
+        restitution: (props.restitution as number) ?? 0,
+        friction: props.friction as number | undefined,
+        compliance: props.compliance as number | undefined,
+        stressStrainCurve: props.stressStrainCurve as PropertiesJson["stressStrainCurve"],
+    });
+};

package/src/material/material-by-name-lookup.ts

@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import type { Entity } from "@adobe/data/ecs";
+
+/** Store or transaction surface that exposes the material name index. */
+export interface MaterialByNameLookup {
+    indexes: {
+        materialByName: { get(args: { name: string }): Entity | null };
+    };
+}

package/src/material/material-defaults.ts

@@ -0,0 +1,26 @@
+import type { MaterialDefinition } from "./material-definition.js";
+import { StressStrainCurve } from "./stress-strain-curve/stress-strain-curve.js";
+
+/** Shared defaults for solid materials missing optional simulation / PBR fields. */
+export const solidDefaults = {
+    friction: 0.5,
+    compliance: 1e-8,
+    normalScale: 1,
+    occlusionStrength: 1,
+    viscosity: 0,
+    thermalConductivity: 0,
+    irReflectance: 0,
+    irEmission: 0,
+    emissionMode: 0,
+    baseColorUrl: "",
+    metallicRoughnessUrl: "",
+    normalUrl: "",
+    occlusionUrl: "",
+    emissiveUrl: "",
+    stressStrainCurve: StressStrainCurve.create({
+        tensileYieldStrainStress: [0, 0],
+        tensileFractureStrainStress: [0, 0],
+        compressiveYieldStrainStress: [0, 0],
+        compressiveFractureStrainStress: [0, 0],
+    }),
+} as const satisfies Partial<MaterialDefinition>;

package/src/material/material-definition.ts

@@ -0,0 +1,4 @@
+import type { Material } from "./material.js";
+
+/** Material property bundle without registry name (defaults merged at insert). */
+export type MaterialDefinition = Partial<Omit<Material, "name">>;

package/src/material/material-name.ts

@@ -0,0 +1,3 @@
+import type { definitions } from "./definitions.js";
+
+export type MaterialName = keyof typeof definitions;

package/src/material/material-plugin.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "vitest";
+import { Database } from "@adobe/data/ecs";
+import { plugin } from "./material-plugin.js";
+import { assembleMaterialRow } from "./assemble-material-row.js";
+import { requireMaterial } from "./require-material.js";
+import { solidDefaults } from "./material-defaults.js";
+import { StressStrainCurve } from "./stress-strain-curve/stress-strain-curve.js";
+
+const noSolidCurve = StressStrainCurve.create({
+    tensileYieldStrainStress: [0, 0],
+    tensileFractureStrainStress: [0, 0],
+    compressiveYieldStrainStress: [0, 0],
+    compressiveFractureStrainStress: [0, 0],
+});
+
+const rockRow = {
+    name: "rock",
+    ...solidDefaults,
+    baseColorFactor: [0.5, 0.5, 0.5, 1] as const,
+    emissiveFactor: [0, 0, 0] as const,
+    metallicFactor: 0,
+    roughnessFactor: 0.8,
+    irReflectance: 0.1,
+    irEmission: 0,
+    emissionMode: 0,
+    restitution: 0.15,
+    density: 2650,
+    viscosity: 0,
+    heatCapacity: 800,
+    thermalConductivity: 4,
+    stressStrainCurve: noSolidCurve,
+};
+
+describe("materialByName index", () => {
+    it("returns the material entity for a known name", () => {
+        const db = Database.create(plugin);
+        const rock = db.transactions.insertMaterial(rockRow);
+        expect(db.indexes.materialByName.get({ name: "rock" })).toBe(rock);
+    });
+
+    it("returns null for an unknown name", () => {
+        const db = Database.create(plugin);
+        expect(db.indexes.materialByName.get({ name: "missing" })).toBeNull();
+    });
+
+    it("is populated by seedStandardMaterials", () => {
+        const db = Database.create(plugin);
+        db.transactions.seedStandardMaterials();
+        expect(db.indexes.materialByName.get({ name: "steel" })).not.toBeNull();
+        expect(db.indexes.materialByName.get({ name: "ice" })).not.toBeNull();
+    });
+
+    it("rejects duplicate material names", () => {
+        const db = Database.create(plugin);
+        db.transactions.insertMaterial(rockRow);
+        expect(() => db.transactions.insertMaterial(rockRow)).toThrow(/Unique index conflict/);
+    });
+
+    it("insertMaterial validates required fields", () => {
+        const db = Database.create(plugin);
+        expect(() => db.transactions.insertMaterial({ ...rockRow, density: undefined as unknown as number })).toThrow(/missing required fields.*density/);
+    });
+});
+
+describe("requireMaterial", () => {
+    it("returns the material entity for a known name", () => {
+        const db = Database.create(plugin);
+        const rock = db.transactions.insertMaterial(rockRow);
+        expect(requireMaterial(db, "rock")).toBe(rock);
+    });
+
+    it("throws when the material was never seeded", () => {
+        const db = Database.create(plugin);
+        expect(() => requireMaterial(db, "missing")).toThrow(/Material "missing" is not in the registry/);
+    });
+});
+
+describe("assembleMaterialRow", () => {
+    it("throws when a required field is missing from the definition", () => {
+        expect(() => assembleMaterialRow("bad", { baseColorFactor: [1, 1, 1, 1] })).toThrow(/missing required fields.*density/);
+    });
+
+    it("merges solidDefaults and returns a full row", () => {
+        const row = assembleMaterialRow("rock", {
+            baseColorFactor: [0.5, 0.5, 0.5, 1],
+            emissiveFactor: [0, 0, 0],
+            metallicFactor: 0,
+            roughnessFactor: 0.8,
+            density: 2650,
+            restitution: 0.15,
+            heatCapacity: 800,
+        });
+        expect(row.name).toBe("rock");
+        expect(row.density).toBe(2650);
+        expect(row.friction).toBe(solidDefaults.friction);
+    });
+});

package/src/material/material-plugin.ts

@@ -1,61 +1,89 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
 import { Database, Entity } from "@adobe/data/ecs";
-import { F32, Vec3, Vec4 } from "@adobe/data/math";
+import { F32, U32, Vec3, Vec4 } from "@adobe/data/math";
+import { definitions } from "./definitions.js";
+import type { Material } from "./material.js";
+import type { MaterialDefinition } from "./material-definition.js";
+import type { MaterialName } from "./material-name.js";
+import { solidDefaults } from "./material-defaults.js";
+import { assembleMaterialRow } from "./assemble-material-row.js";
 import { standardMaterials } from "./standard-materials.js";
+import { StressStrainCurve } from "./stress-strain-curve/stress-strain-curve.js";
 
 /**
- * The material registry — authored materials as ECS entities (an open set;
- * added rarely, edited never). Each `Material` row carries physical props (read
- * by any solver) and visible PBR factors + texture-source URLs (read by the
- * renderer). A body / model references a material by `Entity` id; the
- * render-side `materialGpu` plugin derives GPU textures + a palette from these
- * rows and caches them, rebuilding only when a new material appears.
- *
- * `seedStandardMaterials` inserts the standard library and records a
- * `name → Entity` lookup in the `materials` resource.
+ * Material registry — each material type is one `Material` entity with every
+ * property as its own ECS component. Bodies reference a material by entity id.
+ * Lookup by name via `indexes.materialByName`.
  */
 export const plugin = Database.Plugin.create({
     components: {
-        /** Reference (on a body, prop, or model) to a Material registry entity. */
-        material:             Entity.schema,
-        name:                 { type: "string" },
-        density:              F32.schema,
-        restitution:          F32.schema,
-        friction:             F32.schema,
-        compliance:           F32.schema,
-        heatCapacity:         F32.schema,
-        baseColorFactor:      Vec4.schema,
-        emissiveFactor:       Vec3.schema,
-        metallicFactor:       F32.schema,
-        roughnessFactor:      F32.schema,
-        normalScale:          F32.schema,
-        occlusionStrength:    F32.schema,
-        baseColorUrl:         { type: "string" },
+        /** Reference on a body, prop, or voxel to a Material registry entity. */
+        material: Entity.schema,
+        name: { type: "string" },
+        // rigid-body physics
+        density: F32.schema,
+        restitution: F32.schema,
+        friction: F32.schema,
+        compliance: F32.schema,
+        heatCapacity: F32.schema,
+        // simulation
+        viscosity: F32.schema,
+        thermalConductivity: F32.schema,
+        stressStrainCurve: StressStrainCurve.schema,
+        // visible PBR
+        baseColorFactor: Vec4.schema,
+        emissiveFactor: Vec3.schema,
+        metallicFactor: F32.schema,
+        roughnessFactor: F32.schema,
+        normalScale: F32.schema,
+        occlusionStrength: F32.schema,
+        irReflectance: F32.schema,
+        irEmission: F32.schema,
+        emissionMode: U32.schema,
+        // texture sources
+        baseColorUrl: { type: "string" },
         metallicRoughnessUrl: { type: "string" },
-        normalUrl:            { type: "string" },
-        occlusionUrl:         { type: "string" },
-        emissiveUrl:          { type: "string" },
-    },
-    resources: {
-        /** name → Material entity, populated by `seedStandardMaterials`. */
-        materials: { default: {} as Record<string, Entity> },
+        normalUrl: { type: "string" },
+        occlusionUrl: { type: "string" },
+        emissiveUrl: { type: "string" },
     },
     archetypes: {
         Material: [
             "name",
             "density", "restitution", "friction", "compliance", "heatCapacity",
-            "baseColorFactor", "emissiveFactor", "metallicFactor", "roughnessFactor", "normalScale", "occlusionStrength",
+            "viscosity", "thermalConductivity", "stressStrainCurve",
+            "baseColorFactor", "emissiveFactor", "metallicFactor", "roughnessFactor",
+            "normalScale", "occlusionStrength", "irReflectance", "irEmission", "emissionMode",
             "baseColorUrl", "metallicRoughnessUrl", "normalUrl", "occlusionUrl", "emissiveUrl",
         ],
     },
+    indexes: {
+        materialByName: { key: "name", unique: true, archetype: "Material" },
+    },
     transactions: {
+        insertMaterial(t, row: Material): Entity {
+            const { name, ...definition } = row;
+            return t.archetypes.Material.insert(assembleMaterialRow(name, definition));
+        },
+        insertMaterialDefinition(t, args: { name: string; definition: MaterialDefinition }): Entity {
+            return t.archetypes.Material.insert(assembleMaterialRow(args.name, args.definition));
+        },
+        insertMaterialDefinitions(t, defs: Readonly<Record<string, MaterialDefinition>>): void {
+            for (const [name, definition] of Object.entries(defs)) {
+                t.archetypes.Material.insert(assembleMaterialRow(name, definition));
+            }
+        },
+        /** Textured PBR library used by graphics samples (rubber, wood, stone, steel, ice). */
         seedStandardMaterials(t) {
-            const map: Record<string, Entity> = {};
-            for (const m of standardMaterials) {
-                map[m.name] = t.archetypes.Material.insert(m);
+            for (const row of standardMaterials) {
+                const { name, ...definition } = row;
+                t.archetypes.Material.insert(assembleMaterialRow(name, definition));
+            }
+        },
+        /** Solid material library from `definitions` (authored catalog). */
+        seedDefinitionMaterials(t) {
+            for (const name of Object.keys(definitions) as MaterialName[]) {
+                t.archetypes.Material.insert(assembleMaterialRow(name, definitions[name]));
             }
-            t.resources.materials = map;
         },
     },
 });

package/src/material/material.ts

@@ -1,38 +1,39 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
 import type { Vec3, Vec4 } from "@adobe/data/math";
+import type { StressStrainCurve } from "./stress-strain-curve/stress-strain-curve.js";
+
+/** One row of the `Material` archetype — one entity per material type. */
+export type Material = {
+    readonly name: string;
+
+    // rigid-body physics
+    readonly density: number;
+    readonly restitution: number;
+    readonly friction: number;
+    readonly compliance: number;
+    readonly heatCapacity: number;
+
+    // simulation (thermal / fluid / mechanical)
+    readonly viscosity: number;
+    readonly thermalConductivity: number;
+    readonly stressStrainCurve: StressStrainCurve;
+
+    // visible PBR factors
+    readonly baseColorFactor: Vec4;
+    readonly emissiveFactor: Vec3;
+    readonly metallicFactor: number;
+    readonly roughnessFactor: number;
+    readonly normalScale: number;
+    readonly occlusionStrength: number;
+    readonly irReflectance: number;
+    readonly irEmission: number;
+    readonly emissionMode: number;
 
-/**
- * One row of the `Material` archetype — an authored material carrying both its
- * physical properties (read by any physics solver) and its visible PBR
- * properties (read by the renderer / material-array builder). Materials are an
- * open, data-driven registry, not a closed enum: add a row, never edit code.
- *
- * Texture maps are *sources* (URLs) fetched at runtime; `""` means "use the
- * neutral fallback layer". `metallicRoughnessUrl` and `occlusionUrl` may point
- * at the same ARM image (AO = R, Roughness = G, Metalness = B).
- */
-export interface Material {
-    name: string;
-    // physical (read by any solver)
-    density: number;
-    restitution: number;
-    friction: number;
-    compliance: number;
-    heatCapacity: number;
-    // visible PBR factors (multipliers over the sampled maps)
-    baseColorFactor: Vec4;
-    emissiveFactor: Vec3;
-    metallicFactor: number;
-    roughnessFactor: number;
-    normalScale: number;
-    occlusionStrength: number;
-    // texture sources, fetched at runtime ("" = neutral fallback layer)
-    baseColorUrl: string;
-    metallicRoughnessUrl: string;
-    normalUrl: string;
-    occlusionUrl: string;
-    emissiveUrl: string;
-}
+    // texture sources ("" = factor-only / neutral GPU layer)
+    readonly baseColorUrl: string;
+    readonly metallicRoughnessUrl: string;
+    readonly normalUrl: string;
+    readonly occlusionUrl: string;
+    readonly emissiveUrl: string;
+};
 
 export * as Material from "./public.js";

package/src/material/public.ts

@@ -1,4 +1,14 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-export { plugin } from "./material-plugin.js";
-export { standardMaterials } from "./standard-materials.js";
+export * from "./material-plugin.js";
+export * from "./emission-mode.js";
+export * from "./assemble-material-row.js";
+export * from "./require-material.js";
+export * from "./material-by-name-lookup.js";
+export * from "./standard-material-names.js";
+export * from "./standard-materials.js";
+export * from "./definitions.js";
+export * from "./material-defaults.js";
+export * from "./material-name.js";
+export * from "./material.js";
+export * as MaterialJson from "./json/public.js";

package/src/material/require-material.ts

@@ -0,0 +1,15 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import type { Entity } from "@adobe/data/ecs";
+import type { MaterialByNameLookup } from "./material-by-name-lookup.js";
+
+/** Returns the material entity for `name`, or throws if it was never seeded. */
+export const requireMaterial = (db: MaterialByNameLookup, name: string): Entity => {
+    const material = db.indexes.materialByName.get({ name });
+    if (material == null) {
+        throw new Error(
+            `Material "${name}" is not in the registry — seed materials first (seedStandardMaterials or seedDefinitionMaterials).`,
+        );
+    }
+    return material;
+};

package/src/material/standard-material-names.ts

@@ -0,0 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+/** Names seeded by `seedStandardMaterials`. */
+export const standardMaterialNames = ["rubber", "wood", "stone", "steel", "ice"] as const;

package/src/material/standard-materials.ts

@@ -1,43 +1,37 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// PBR texture maps © Poly Haven, CC0 (https://polyhaven.com). Fetched at
-// runtime by URL — never committed (see data-gpu-samples/CLAUDE.md). Poly
-// Haven's `arm` map packs AO(R) / Roughness(G) / Metalness(B), matching glTF's
-// occlusion + metallicRoughness channel conventions.
 
 import type { Material } from "./material.js";
+import { solidDefaults } from "./material-defaults.js";
 
-const tex = (slug: string, map: string): string =>
-    `https://dl.polyhaven.org/file/ph-assets/Textures/jpg/1k/${slug}/${slug}_${map}_1k.jpg`;
-
-/**
- * A standard material: physical constants (the old material table) plus neutral
- * visible factors — the textures supply colour / roughness / metalness, so the
- * factors are left at 1 and baseColor white.
- */
-function standard(
-    name: string, slug: string,
+/** Factor-only sample materials (no map URLs — rendered via `pbrFactorRender`). */
+function factor(
+    name: string,
+    baseColorFactor: [number, number, number, number],
+    metallicFactor: number,
+    roughnessFactor: number,
     density: number, restitution: number, friction: number, compliance: number, heatCapacity: number,
 ): Material {
     return {
         name,
+        ...solidDefaults,
         density, restitution, friction, compliance, heatCapacity,
-        baseColorFactor: [1, 1, 1, 1],
+        baseColorFactor,
         emissiveFactor: [0, 0, 0],
-        metallicFactor: 1, roughnessFactor: 1, normalScale: 1, occlusionStrength: 1,
-        baseColorUrl: tex(slug, "diff"),
-        metallicRoughnessUrl: tex(slug, "arm"),
-        normalUrl: tex(slug, "nor_gl"),
-        occlusionUrl: tex(slug, "arm"),
+        metallicFactor,
+        roughnessFactor,
+        baseColorUrl: "",
+        metallicRoughnessUrl: "",
+        normalUrl: "",
+        occlusionUrl: "",
         emissiveUrl: "",
     };
 }
 
-/** The standard material library, seeded by `seedStandardMaterials`. */
+/** Small factor library seeded by `seedStandardMaterials`. */
 export const standardMaterials: readonly Material[] = [
-    standard("rubber", "rubber_tiles",         1.1,  0.80, 0.90, 1e-5, 2.0),
-    standard("wood",   "wood_table_001",       0.6,  0.35, 0.70, 5e-7, 1.7),
-    standard("stone",  "cobblestone_floor_08", 2.6,  0.20, 0.85, 1e-8, 0.8),
-    standard("steel",  "metal_plate",          7.8,  0.45, 0.50, 1e-9, 0.5),
-    standard("ice",    "snow_02",              0.92, 0.25, 0.05, 5e-9, 2.1),
+    factor("rubber", [0.15, 0.15, 0.15, 1], 0.0, 0.90, 1.1,  0.80, 0.90, 1e-5, 2.0),
+    factor("wood",   [0.55, 0.35, 0.20, 1], 0.0, 0.75, 0.6,  0.35, 0.70, 5e-7, 1.7),
+    factor("stone",  [0.45, 0.43, 0.40, 1], 0.05, 0.85, 2.6,  0.20, 0.85, 1e-8, 0.8),
+    factor("steel",  [0.70, 0.72, 0.75, 1], 0.9, 0.35, 7.8,  0.45, 0.50, 1e-9, 0.5),
+    factor("ice",    [0.85, 0.92, 0.95, 1], 0.0, 0.15, 0.92, 0.25, 0.05, 5e-9, 2.1),
 ];

package/src/material/stress-strain-curve/create.ts

@@ -0,0 +1,9 @@
+import type { Vec2 } from "@adobe/data/math";
+import type { StressStrainCurve } from "./stress-strain-curve.js";
+
+export const create = (args: {
+    readonly tensileYieldStrainStress: Vec2;
+    readonly tensileFractureStrainStress: Vec2;
+    readonly compressiveYieldStrainStress: Vec2;
+    readonly compressiveFractureStrainStress: Vec2;
+}): StressStrainCurve => args;

package/src/material/stress-strain-curve/public.ts

@@ -0,0 +1,2 @@
+export { schema } from "./schema.js";
+export { create } from "./create.js";

package/src/material/stress-strain-curve/schema.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { getStructLayout } from "@adobe/data/typed-buffer";
+import { StressStrainCurve } from "./stress-strain-curve.js";
+
+describe("StressStrainCurve.schema — struct layout", () => {
+    it("is a valid struct layout", () => {
+        expect(() => getStructLayout(StressStrainCurve.schema)).not.toThrow();
+    });
+
+    it("uses packed layout with four vec2 fields", () => {
+        const layout = getStructLayout(StressStrainCurve.schema);
+
+        expect(layout.layout).toBe("packed");
+        expect(layout.size).toBe(32);
+        expect(layout.fields.tensileYieldStrainStress.offset).toBe(0);
+        expect(layout.fields.tensileFractureStrainStress.offset).toBe(8);
+        expect(layout.fields.compressiveYieldStrainStress.offset).toBe(16);
+        expect(layout.fields.compressiveFractureStrainStress.offset).toBe(24);
+    });
+});

package/src/material/stress-strain-curve/schema.ts

@@ -0,0 +1,20 @@
+import { Vec2 } from "@adobe/data/math";
+import { Schema } from "@adobe/data/schema";
+
+/** Uniaxial bilinear σ–ε curve points. Each Vec2 is [engineering strain, stress MPa]. */
+export const schema = {
+    type: "object",
+    layout: "packed",
+    properties: {
+        tensileYieldStrainStress: Vec2.schema,
+        tensileFractureStrainStress: Vec2.schema,
+        compressiveYieldStrainStress: Vec2.schema,
+        compressiveFractureStrainStress: Vec2.schema,
+    },
+    required: [
+        "tensileYieldStrainStress",
+        "tensileFractureStrainStress",
+        "compressiveYieldStrainStress",
+        "compressiveFractureStrainStress",
+    ],
+} as const satisfies Schema;

package/src/material/stress-strain-curve/stress-strain-curve.ts

@@ -0,0 +1,11 @@
+import { Schema } from "@adobe/data/schema";
+import type { Assert, Equal } from "@adobe/data/types";
+import { schema } from "./schema.js";
+
+export type StressStrainCurve = Schema.ToType<typeof schema>;
+
+type _StressStrainCurveMatchesSchema = Assert<
+    Equal<StressStrainCurve, Schema.ToType<typeof schema>>
+>;
+
+export * as StressStrainCurve from "./public.js";

package/src/physics/README.md

@@ -1,10 +1,18 @@
 # Physics — feature roadmap
 
-A general-purpose, solver-agnostic physics layer for `@adobe/data-gpu`, suitable
+A general-purpose, solver-agnostic physics layer for `@adobe/data-gpu/physics`, suitable
 for games, visualisation, and film/animation. Bodies are authored as ECS data
 against a shared seam (`physicsData`); a pluggable **solver** (Jolt or Rapier)
 advances them each frame. See `solvers/README.md` for choosing a solver.
 
+```ts
+import { physicsData, joltSolver, rapierSolver } from "@adobe/data-gpu/physics";
+import { core } from "@adobe/data-gpu";
+import { physicsRenderBridge } from "@adobe/data-gpu/graphics";
+
+const scene = Database.Plugin.combine(core, physicsData, joltSolver, physicsRenderBridge);
+```
+
 This file is the running plan — check the box when a feature lands so we don't
 lose track. Keep it honest about approximations and limitations.
 

package/src/physics/body/collider-shape/mass-from-volume.test.ts

@@ -0,0 +1,8 @@
+import { describe, expect, it } from "vitest";
+import { massFromVolume } from "./mass-from-volume.js";
+
+describe("massFromVolume", () => {
+    it("multiplies volume by density", () => {
+        expect(massFromVolume(2, 1000)).toBe(2000);
+    });
+});

package/src/physics/body/collider-shape/mass-from-volume.ts

@@ -0,0 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+/** Mass (kg) from collider volume (m³) and material density (kg/m³). */
+export const massFromVolume = (volume: number, density: number): number => volume * density;

package/src/physics/collider-primitive-render-archetype.ts

@@ -0,0 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import type { COLLIDER_PRIMITIVE_RENDER_ARCHETYPES } from "./collider-primitive-render-archetypes.js";
+
+export type ColliderPrimitiveRenderArchetype = (typeof COLLIDER_PRIMITIVE_RENDER_ARCHETYPES)[number];

package/src/physics/collider-primitive-render-archetypes.ts

@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+/** Physics archetypes whose visual mesh is the collider primitive (not an external override). */
+export const COLLIDER_PRIMITIVE_RENDER_ARCHETYPES = [
+    "RigidBody",
+    "StaticCollider",
+    "ConvexBody",
+    "MeshCollider",
+] as const;