@adatechnology/game-destruction 0.13.2 → 0.15.0

package/README.md

@@ -383,6 +383,11 @@ helpers `vec`, `quat`, `quatFromEuler`, `rotateVec`, `toLocal`, `toWorld`, the l
 The locale table has `en` and `pt-BR` strings for material names, part statuses, joint kinds, tools, damage types, event labels and fracture styles:
 `resolveStrings('pt-BR').materialNames.glass === 'vidro'`. Unknown locales fall back to `en`.
 
+## Assemblies by instance
+
+`createAssemblies({ packs, patch, remove })` makes a set of assemblies of its own: the built-in ones plus `packs`. `packs` is a list of lists of `AssemblyDef` (`[[wallDef, doorDef], [extraDef]]`); a def with the id of a built-in replaces it.
+`patch` merges fields by assembly id, `remove` lists ids to take out. The global `ASSEMBLIES`, `registerAssembly` and the rest are deprecated delegates of `defaultAssemblies()`.
+
 ## Português
 
 Modelo de destruição independente de engine. Um objeto é um conjunto de peças (caixa, cilindro ou esfera com um material) unidas por juntas. O

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Vec3, Quat, MaterialId, FractureStyle, DamageType, DebrisKind, DestructionEvent, StructureRole, SoilProfile, WindExposure, IgnitionRules, BlastOptions, DestructibleSpec, ObjectState, DestructibleImpl, Hit, HitResult, RayHit, BallisticExtras, ToolKind, JointState, PartState, DestructionEventType, ConfinementOptions, FragmentHitOptions, ShelterOptions, ExplosionChain, PartSpec, JointKind, JointSpec, PartShape, SurfaceLayer, PartUnits, Reinforcement, PartBreach, PileSpec, PartStatus } from '@adatechnology/game-contracts';
+import { Vec3, Quat, MaterialId, FractureStyle, DamageType, DebrisKind, DestructionEvent, StructureRole, SoilProfile, WindExposure, IgnitionRules, BlastOptions, DestructibleSpec, ObjectState, DestructibleImpl, Hit, HitResult, ShelterOptions, RayHit, BallisticExtras, ToolKind, JointState, PartState, DestructionEventType, ConfinementOptions, FragmentHitOptions, ExplosionChain, PartSpec, JointKind, JointSpec, PartShape, SurfaceLayer, PartUnits, Reinforcement, PartBreach, DeepPartial, PileSpec, PartStatus, CostOptions } from '@adatechnology/game-contracts';
 export { BallisticExtras, BlastOptions, BlastReport, ChainDelay, ConfinementOptions, Crack, DamageStage, DamageType, DebrisKind, Dent, DestructibleImpl, DestructibleSpec, DestructionEvent, DestructionEventType, ExplosionChain, FluidKind, FractureStyle, Fragment, FragmentHitOptions, FragmentMark, Hit, HitIgnition, HitResult, Hole, IMPACT_CONTRACT, ImpactContract, JointKind, JointSpec, JointState, MaterialId, ObjectState, PartBreach, PartShape, PartSpec, PartState, PartStatus, PartUnits, PileSpec, Quat, RayHit, Reinforcement, ShelterOptions, SoilLayer, SoilProfile, SoilState, StructureRole, SurfaceLayer, TensionRebar, ToolKind, TunedMassDamper, Vec3, WindExposure, WindState, checkHit } from '@adatechnology/game-contracts';
 
 /**
@@ -324,6 +324,11 @@ interface DestructionOptions {
     maxDents?: number;
     /** Maximum holes kept per part (default 32). */
     maxHoles?: number;
+    /**
+     * Most primed explosives that go off in one `update` (default: no cap). The rest wait, ordered by due time, then older object, then part
+     * order, and go off in the next updates, so a long chain spreads over steps by count and not by the speed of the machine.
+     */
+    chainLinksPerUpdate?: number;
     /** Distance at which a burning part heats parts of other objects, in metres (default 0.6). */
     fireSpread?: number;
     /**
@@ -452,6 +457,16 @@ interface DestructionWorld {
      * that target, and a `blast` event sums it up.
      */
     explode(point: Vec3, energy: number, radius: number, source?: string, options?: BlastOptions): HitResult[];
+    /**
+     * The share (0..1) of a blast at `point` that reaches `target` through what stands between them: every part the straight line crosses lets
+     * `exp(-r / k)` through (`ShelterOptions`; `r` the hit points of the slab per square metre), a broken part or a hole lets it all by. Always on, whatever
+     * `BlastOptions.shelter` says: the shove of a blast (people, the player, loose things) is blocked by cover in every room. `ignore` lists objects that never
+     * block (the explosive itself, the body being shoved).
+     */
+    blastReach(point: Vec3, target: Vec3, options?: {
+        readonly ignore?: readonly string[];
+        readonly shelter?: ShelterOptions;
+    }): number;
     /** Cost of the last `explode`: parts in range of the broad phase (`partsTested`) and those whose bounding sphere the blast reached (`partsNear`). */
     blastProbe(): {
         partsTested: number;
@@ -711,16 +726,38 @@ interface AssemblyPartOptions {
     /** Materials to read densities from (default the built-in `MATERIALS`). */
     materials?: ReadonlyMap<MaterialId, MaterialDef>;
 }
-/** Built-in assemblies; `registerAssembly` adds to this list. */
+/**
+ * Built-in assemblies; `registerAssembly` adds to this list.
+ * @deprecated the list every page shares. Use `createAssemblies({ packs, patch, remove })`, or `defaultAssemblies()` for this one.
+ */
 declare const ASSEMBLIES: AssemblyDef[];
+interface AssembliesOptions {
+    /** Assemblies added to the built-in ones; one with the id of a built-in replaces it. */
+    readonly packs?: readonly (readonly AssemblyDef[])[];
+    /** Changes by id, merged field by field over what is there. */
+    readonly patch?: Readonly<Record<string, DeepPartial<AssemblyDef>>>;
+    /** Ids taken out. */
+    readonly remove?: readonly string[];
+}
+interface Assemblies {
+    list(): readonly AssemblyDef[];
+    get(id: string): AssemblyDef | undefined;
+    /** Adds an assembly, or replaces the one with the same id. */
+    register(def: AssemblyDef): void;
+    /** The wall as a `PartSpec`; throws for an id this set does not have. */
+    part(assemblyId: string, options: AssemblyPartOptions): PartSpec;
+}
+/** A set of assemblies of its own: the built-in ones (copied) plus `packs`, `patch` and `remove`. Nothing is shared with any other set on the page. */
+declare const createAssemblies: (options?: AssembliesOptions) => Assemblies;
+/** The set behind `ASSEMBLIES`, `registerAssembly`, `getAssembly` and `assemblyPart`, created on first use. */
+declare const defaultAssemblies: () => Assemblies;
+/** @deprecated use `createAssemblies(...).register`. */
 declare const registerAssembly: (def: AssemblyDef) => void;
+/** @deprecated use `createAssemblies(...).get`. */
 declare const getAssembly: (id: string) => AssemblyDef | undefined;
 /** Physical depth of the wall in metres. */
 declare const assemblyDepth: (def: AssemblyDef) => number;
-/**
- * The wall as a box `[width, height, depth]` (thin along local z) with the assembly's layers, units, rebar and breach. Mass is the core (times `fill`)
- * plus the coats; `thickness` is the core's, so each coat adds its own `penetration x thickness` to what a bullet must cross.
- */
+/** @deprecated use `createAssemblies(...).part`. */
 declare const assemblyPart: (assemblyId: string, options: AssemblyPartOptions) => PartSpec;
 
 interface FrameOptions {
@@ -1086,6 +1123,8 @@ declare const resolveStrings: (locale: string | undefined) => DestructionStrings
 interface CheckOptions {
     /** Ids of custom materials the impl uses besides the built-in `MATERIALS`. */
     materials?: string[];
+    /** Opt-in cost measurement of `state()` and `describe()` (D8). */
+    cost?: boolean | CostOptions;
 }
 /**
  * `checkDestructible` of `@adatechnology/game-contracts`, with the built-in `MATERIALS` (plus `options.materials`) as the known material ids.
@@ -1361,4 +1400,4 @@ declare const tensionCapacity: (dims: Vec3, o: {
     tensileMPa?: number;
 }) => number;
 
-export { ASSEMBLIES, type AddOptions, type AssemblyDef, type AssemblyPartOptions, type BearingWallOptions, type BendGeometry, type BendSection, CONFINEMENT_DEFAULTS, type ChainTrigger, type CheckOptions, type DestructionLocale, type DestructionOptions, type DestructionSnapshot, type DestructionStrings, type DestructionWorld, type ExplosivePartOptions, FIRE_PRIME_C, FLEXURE_DEFAULTS, FRAGMENT_HIT_DEFAULTS, type FlexureOptions, type FoundationSolve, type FrameOptions, GRAVITY, type Gust, JOINT_BY_MATERIALS, JOINT_DEFAULTS, MASONRY_DEFAULTS, MATERIALS, type MasonryOptions, type MaterialDef, type MaterialHit, type MaterialStrength, type MaterialThermal, type ObjectRuntime, type PartRuntime, type ResolvedWind, SHELTER_DEFAULTS, SOILS, SOIL_DEFAULTS, type SectionMoments, type SizeStructureOptions, type SoilDef, type SoilKind, type SoilOptions, type SoilSpring, type SwayState, type SwaySystem, type TensionSteel, WIND_DEFAULTS, WIND_TERRAIN, type WallFrameSolution, type WindAnalysis, type WindCase, type WindOptions, type WindPartInput, type WindTerrainDef, type WorldExplosive, analyzeWind, assemblyDepth, assemblyPart, bearingWallThickness, bendGeometry, blastImpulse, buildFrame, checkDestructible, crackingMoment, createDestruction, damperAmplification, damperTuning, elasticEnergy, explosivePart, exposureOf, footingArea, footingSoil, fragility, getAssembly, guessMaterial, gustAt, heightFactor, impulseEnergy, inferJoints, layersBetween, locales, makeGust, meanHeightFactor, momentNodes, momentOfEnergy, partCapacity, partMass, partThickness, partVolume, pileCapacity, pileLength, pileStiffness, profileOf, quat, quatFromEuler, registerAssembly, resolveStrings, resolveWind, rotateVec, sectionMoments, shapeAt, shearNodes, sizeRebar, sizeStructure, slendernessFactor, soilAt, solveFoundation, solveWallFrame, spanMoment, spanOf, steelMoment, stepSway, stiffnessCentre, subgradeModulus, tBeamInertia, tensionCapacity, tensionSteel, toLocal, toWorld, turbulenceIntensity, vec, windClass, windPressure };
+export { ASSEMBLIES, type AddOptions, type Assemblies, type AssembliesOptions, type AssemblyDef, type AssemblyPartOptions, type BearingWallOptions, type BendGeometry, type BendSection, CONFINEMENT_DEFAULTS, type ChainTrigger, type CheckOptions, type DestructionLocale, type DestructionOptions, type DestructionSnapshot, type DestructionStrings, type DestructionWorld, type ExplosivePartOptions, FIRE_PRIME_C, FLEXURE_DEFAULTS, FRAGMENT_HIT_DEFAULTS, type FlexureOptions, type FoundationSolve, type FrameOptions, GRAVITY, type Gust, JOINT_BY_MATERIALS, JOINT_DEFAULTS, MASONRY_DEFAULTS, MATERIALS, type MasonryOptions, type MaterialDef, type MaterialHit, type MaterialStrength, type MaterialThermal, type ObjectRuntime, type PartRuntime, type ResolvedWind, SHELTER_DEFAULTS, SOILS, SOIL_DEFAULTS, type SectionMoments, type SizeStructureOptions, type SoilDef, type SoilKind, type SoilOptions, type SoilSpring, type SwayState, type SwaySystem, type TensionSteel, WIND_DEFAULTS, WIND_TERRAIN, type WallFrameSolution, type WindAnalysis, type WindCase, type WindOptions, type WindPartInput, type WindTerrainDef, type WorldExplosive, analyzeWind, assemblyDepth, assemblyPart, bearingWallThickness, bendGeometry, blastImpulse, buildFrame, checkDestructible, crackingMoment, createAssemblies, createDestruction, damperAmplification, damperTuning, defaultAssemblies, elasticEnergy, explosivePart, exposureOf, footingArea, footingSoil, fragility, getAssembly, guessMaterial, gustAt, heightFactor, impulseEnergy, inferJoints, layersBetween, locales, makeGust, meanHeightFactor, momentNodes, momentOfEnergy, partCapacity, partMass, partThickness, partVolume, pileCapacity, pileLength, pileStiffness, profileOf, quat, quatFromEuler, registerAssembly, resolveStrings, resolveWind, rotateVec, sectionMoments, shapeAt, shearNodes, sizeRebar, sizeStructure, slendernessFactor, soilAt, solveFoundation, solveWallFrame, spanMoment, spanOf, steelMoment, stepSway, stiffnessCentre, subgradeModulus, tBeamInertia, tensionCapacity, tensionSteel, toLocal, toWorld, turbulenceIntensity, vec, windClass, windPressure };

package/dist/index.global.js

@@ -47,9 +47,11 @@ var GameDestruction = (() => {
     checkDestructible: () => checkDestructible2,
     checkHit: () => checkHit,
     crackingMoment: () => crackingMoment,
+    createAssemblies: () => createAssemblies,
     createDestruction: () => createDestruction,
     damperAmplification: () => damperAmplification,
     damperTuning: () => damperTuning,
+    defaultAssemblies: () => defaultAssemblies,
     elasticEnergy: () => elasticEnergy,
     explosivePart: () => explosivePart,
     exposureOf: () => exposureOf,
@@ -2780,6 +2782,28 @@ var GameDestruction = (() => {
   };
 
   // ../game-contracts/dist/index.js
+  var DEFAULT_COST_READS = 1e4;
+  var DEFAULT_COST_CEILING_MS = 50;
+  var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
+  var heapUsedBytes = () => {
+    const nodeProcess = globalThis.process;
+    return nodeProcess?.memoryUsage?.().heapUsed;
+  };
+  var checkReadCost = ({ name, read, options, problems }) => {
+    const reads = options.reads ?? DEFAULT_COST_READS;
+    const ceilingMs = options.ceilingMs ?? DEFAULT_COST_CEILING_MS;
+    const allocationBytes = options.allocationBytes ?? DEFAULT_COST_ALLOCATION_BYTES;
+    if (read() !== read()) problems.push(`${name}() returns a new object on each read: cache it between changes (cost contract)`);
+    for (let i = 0; i < reads; i++) read();
+    const heapBefore = heapUsedBytes();
+    const started = performance.now();
+    for (let i = 0; i < reads; i++) read();
+    const elapsedMs = performance.now() - started;
+    const heapAfter = heapUsedBytes();
+    if (elapsedMs > ceilingMs) problems.push(`${name}() took ${elapsedMs.toFixed(1)} ms for ${reads} reads, over the ${ceilingMs} ms ceiling (cost contract)`);
+    if (heapBefore !== void 0 && heapAfter !== void 0 && heapAfter - heapBefore > allocationBytes)
+      problems.push(`${name}() grew the heap by ${heapAfter - heapBefore} bytes over ${reads} reads, over the ${allocationBytes} byte ceiling (cost contract)`);
+  };
   var IMPACT_CONTRACT = {
     ballistic: { required: ["type", "point", "direction", "energy", "caliber"], optional: ["space", "source"], note: "bullets and pellets: joules and diameter in millimetres" },
     blunt: { required: ["type", "point", "energy"], optional: ["direction", "radius", "space", "source"], note: "contact radius in metres (default 3 cm)" },
@@ -2885,6 +2909,15 @@ var GameDestruction = (() => {
     } catch (e) {
       problems.push(`reset() threw: ${String(e)}`);
     }
+    if (options.cost) {
+      const cost = options.cost === true ? {} : options.cost;
+      try {
+        checkReadCost({ name: "state", read: () => impl.state(), options: cost, problems });
+        checkReadCost({ name: "describe", read: () => impl.describe(), options: cost, problems });
+      } catch (e) {
+        problems.push(`cost measurement threw: ${String(e)}`);
+      }
+    }
     return { ok: problems.length === 0, problems };
   };
   var DEFAULT_IGNITION_RULES = {
@@ -2930,6 +2963,103 @@ var GameDestruction = (() => {
     const flame = flameBase * (1 - rules.flameFillInfluence * (1 - k));
     return 1 - (1 - Math.min(1, Math.max(0, spark))) * (1 - Math.min(1, Math.max(0, flame)));
   };
+  var DEFERRED_QUEUE_ID = {
+    DESTRUCTION_EVENTS: "destruction.events",
+    BREACH_PAINT: "floorplan.breach-paint",
+    AUDIO_VOICES: "audio.voices",
+    VEHICLE_CREASE: "vehicles.crease"
+  };
+  var DEFERRED_PRIORITY = {
+    [DEFERRED_QUEUE_ID.DESTRUCTION_EVENTS]: { priority: 300, phase: "present" },
+    [DEFERRED_QUEUE_ID.BREACH_PAINT]: { priority: 250, phase: "present" },
+    [DEFERRED_QUEUE_ID.AUDIO_VOICES]: { priority: 200, phase: "idle", reserveMs: 1 },
+    [DEFERRED_QUEUE_ID.VEHICLE_CREASE]: { priority: 100, phase: "idle" }
+  };
+  var WARNED_KEY = /* @__PURE__ */ Symbol.for("@adatechnology/game-contracts.warned");
+  var warnedKeys = () => {
+    const holder = globalThis;
+    return holder[WARNED_KEY] ?? (holder[WARNED_KEY] = /* @__PURE__ */ new Set());
+  };
+  var isProduction = () => {
+    try {
+      return process.env.NODE_ENV === "production";
+    } catch {
+      return false;
+    }
+  };
+  var isQuiet = () => globalThis.__GAME_KIT_QUIET__ === true;
+  var warnOnce = (key, message) => {
+    if (isQuiet() || isProduction()) return;
+    const seen = warnedKeys();
+    if (seen.has(key)) return;
+    seen.add(key);
+    console.warn(`[game-kit] ${message}`);
+  };
+  var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+  var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+  var deepMerge = (base, patch) => {
+    if (!patch) return base;
+    const result = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+      if (value === void 0 || UNSAFE_KEYS.has(key)) continue;
+      const current = result[key];
+      result[key] = isPlainObject(current) && isPlainObject(value) ? deepMerge(current, value) : value;
+    }
+    return result;
+  };
+  var mergeById = (shipped, extra) => {
+    const entries = /* @__PURE__ */ new Map();
+    for (const entry of [...shipped, ...extra ?? []]) entries.set(entry.id, entry);
+    return entries;
+  };
+  var applyPatches = (entries, patches) => {
+    for (const [id, patch] of Object.entries(patches ?? {})) {
+      const entry = entries.get(id);
+      if (entry) entries.set(id, deepMerge(entry, patch));
+      else warnOnce(`registry.patch.${id}`, `patch for "${id}" ignored: no entry has that id`);
+    }
+  };
+  var removeIds = (entries, ids) => {
+    for (const id of ids ?? []) {
+      if (!entries.delete(id)) warnOnce(`registry.remove.${id}`, `remove of "${id}" ignored: no entry has that id`);
+    }
+  };
+  var SURFACE_IDS = ["concrete", "asphalt", "wood", "tile", "dirt", "grass", "gravel", "sand", "metal", "water", "glass", "carpet"];
+  var GAIT_IDS = ["walk", "run"];
+  var LANDING_IDS = ["light", "heavy"];
+  var BODY_SOUND_IDS = [
+    "jump",
+    "cloth_rustle",
+    "body_fall",
+    "fall_damage",
+    "player_hurt",
+    "player_breath_run",
+    "player_death",
+    "bite",
+    "grab",
+    "punch_swing",
+    "punch_hit_body",
+    "punch_hit_face",
+    "punch_hit_object",
+    "kick_swing",
+    "kick_hit",
+    "kick_hit_object",
+    "shove_two_hands",
+    "knife_swing",
+    "knife_stab",
+    "knife_slash",
+    "knife_hit_object",
+    "blunt_swing",
+    "blunt_hit",
+    "blunt_hit_object",
+    "axe_swing",
+    "axe_chop",
+    "axe_hit_object"
+  ];
+  var footstepSoundId = (surface, gait) => `footstep_${surface}_${gait}`;
+  var FOOTSTEP_SOUND_IDS = SURFACE_IDS.flatMap((surface) => GAIT_IDS.map((gait) => footstepSoundId(surface, gait)));
+  var LAND_SOUND_IDS = SURFACE_IDS.flatMap((surface) => LANDING_IDS.map((landing) => `land_${surface}_${landing}`));
+  var BODY_FOLEY_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
 
   // src/world.ts
   var THIN_SHEET_DISHING = 5e-3;
@@ -3057,6 +3187,7 @@ var GameDestruction = (() => {
     const ignitionRules = resolveIgnitionRules(options.ignition);
     const breachBlastFactor = options.breach?.blastFactor ?? BREACH_BLAST_FACTOR;
     const chipEnergy = options.breach?.chipEnergy ?? CHIP_ENERGY;
+    const chainLinkCap = options.chainLinksPerUpdate !== void 0 && options.chainLinksPerUpdate >= 1 ? Math.floor(options.chainLinksPerUpdate) : Infinity;
     const rng = createRng(options.seed ?? 1);
     const rnd = () => rng.next();
     let time = 0;
@@ -3079,7 +3210,13 @@ var GameDestruction = (() => {
       const typed = listeners.get(e.type);
       if (typed) for (const fn of [...typed]) fn(e);
     };
-    const base = (o, source) => source === void 0 ? { object: o.id, time } : { object: o.id, time, source };
+    let blow;
+    const base = (o, source) => ({
+      object: o.id,
+      time,
+      ...source === void 0 ? {} : { source },
+      ...blow === void 0 ? {} : { blow }
+    });
     const pendingCollapse = /* @__PURE__ */ new Map();
     let runDepth = 0;
     const drainBlasts = () => {
@@ -4004,7 +4141,7 @@ var GameDestruction = (() => {
       if (disc < 0) return true;
       return -b - Math.sqrt(disc) > maxDist;
     };
-    const raycastInternal = (origin, dir, maxDist, ignore, worldOnly = false) => {
+    const raycastInternal = (origin, dir, maxDist, ignore, worldOnly = false, precise = false) => {
       const d = vec.normalize(dir);
       let best = null;
       for (const o of objects.values()) {
@@ -4019,13 +4156,25 @@ var GameDestruction = (() => {
         }
       }
       for (const im of worldOnly ? [] : impls.values()) {
+        let boxHit = null;
         for (const ps of im.impl.describe().parts) {
           if (ignore?.has(`${im.impl.id}\0${ps.id}`)) continue;
           const ov = im.poses.get(ps.id);
           const r = rayPartRaw(im.position, im.rotation, ps, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0]), origin, d, ov?.pos);
-          if (!r || r.t0 < 0 || r.t0 > maxDist) continue;
-          if (!best || r.t0 < best.distance) best = { object: im.impl.id, part: ps.id, point: vec.madd(origin, d, r.t0), normal: r.n, distance: r.t0, pathLen: r.t1 - r.t0 };
+          if (!r || r.t1 < 0 || r.t0 > maxDist) continue;
+          if (r.t0 < 0) {
+            if (precise && im.impl.surfaceRay) boxHit = boxHit ?? { object: im.impl.id, part: ps.id, point: origin, normal: r.n, distance: 0, pathLen: r.t1 };
+            continue;
+          }
+          if (!boxHit || r.t0 < boxHit.distance) boxHit = { object: im.impl.id, part: ps.id, point: vec.madd(origin, d, r.t0), normal: r.n, distance: r.t0, pathLen: r.t1 - r.t0 };
         }
+        if (!boxHit) continue;
+        if (precise && im.impl.surfaceRay) {
+          const far = best ? Math.min(maxDist, best.distance) : maxDist;
+          const implId = im.impl.id;
+          const s = im.impl.surfaceRay({ origin, direction: d, maxDistance: far, ...ignore ? { ignored: (part) => ignore.has(`${implId}\0${part}`) } : {} });
+          if (s && (!best || s.distance < best.distance)) best = { object: implId, part: s.part, point: s.point, normal: s.normal, distance: s.distance, pathLen: s.pathLen };
+        } else if (!best || boxHit.distance < best.distance) best = boxHit;
       }
       return best;
     };
@@ -5212,7 +5361,17 @@ var GameDestruction = (() => {
       res.events = cur.slice(start);
       return res;
     };
-    const doHit = (o, hit, only) => {
+    const withBlow = (type, fn) => () => {
+      const outer = blow;
+      blow = type;
+      try {
+        return fn();
+      } finally {
+        blow = outer;
+      }
+    };
+    const doHit = (o, hit, only) => withBlow(hit.type, () => resolveHit(o, hit, only))();
+    const resolveHit = (o, hit, only) => {
       let point = hit.point;
       let dir = hit.direction;
       if (hit.space === "local") {
@@ -5509,7 +5668,9 @@ var GameDestruction = (() => {
     };
     const detonatePrimed = (until) => {
       const end = time;
-      for (let next = nextPrimed(until); next; next = nextPrimed(until)) {
+      let fired = 0;
+      for (let next = nextPrimed(until); next && fired < chainLinkCap; next = nextPrimed(until)) {
+        fired++;
         primed.delete(next.p);
         time = Math.max(0, Math.min(end, next.p.rt.chainDue));
         next.p.rt.chainDue = void 0;
@@ -5579,6 +5740,7 @@ var GameDestruction = (() => {
         updateBound(o);
       },
       remove(id) {
+        impls.get(id)?.impl.dispose?.();
         objects.delete(id);
         impls.delete(id);
       },
@@ -5648,13 +5810,51 @@ var GameDestruction = (() => {
       blastProbe() {
         return { ...blastProbe };
       },
+      blastReach(point, target, options2 = {}) {
+        const L = vec.distance(point, target);
+        if (L < 1e-4) return 1;
+        const shelter = { ...SHELTER_DEFAULTS, ...options2.shelter };
+        const ignore = new Set(options2.ignore ?? []);
+        const d = vec.scale(vec.sub(target, point), 1 / L);
+        let t = 1;
+        for (const o of objects.values()) {
+          if (ignore.has(o.id) || raySphereMiss(point, d, toWorld(o.st.position, o.st.rotation, o.bc), o.br, L)) continue;
+          for (const p of o.parts) {
+            if (isLost(p) || p.st.stripped) continue;
+            const r = rayPart(o, p, point, d);
+            if (!r) continue;
+            const t0 = Math.max(r.t0, 0);
+            const path = Math.min(r.t1, L) - t0;
+            if (path < shelter.minPath) continue;
+            if (p.st.opening && insideOpening(o, p, toLocal(o.st.position, o.st.rotation, vec.madd(point, d, t0 + path / 2)))) continue;
+            t *= Math.exp(-(p.mat.hpPerKg * p.mat.density * path * (p.mat.damageScale?.shelter ?? 1)) / shelter.k);
+            if (t < 1e-4) return 0;
+          }
+        }
+        for (const im of impls.values()) {
+          if (ignore.has(im.impl.id)) continue;
+          for (const ps of im.impl.describe().parts) {
+            const mat = materials.get(ps.material);
+            if (!mat) continue;
+            const ov = im.poses.get(ps.id);
+            const r = rayPartRaw(im.position, im.rotation, ps, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0]), point, d, ov?.pos);
+            if (!r || r.t1 < 0 || r.t0 > L) continue;
+            let path = Math.min(r.t1, L) - Math.max(r.t0, 0);
+            if (ps.thickness !== void 0 && ps.thickness > 0) path = Math.min(path, 2 * ps.thickness);
+            else if (path < shelter.minPath) continue;
+            t *= Math.exp(-(mat.hpPerKg * mat.density * path * (mat.damageScale?.shelter ?? 1)) / shelter.k);
+            if (t < 1e-4) return 0;
+          }
+        }
+        return t;
+      },
       explode(point, energy, radius, source, blast) {
         blastProbe.partsTested = 0;
         blastProbe.partsNear = 0;
         return withCollapses(run(() => blastWorld(point, energy, radius, source, blast)));
       },
       raycast(origin, direction, maxDistance = Infinity) {
-        const r = raycastInternal(origin, direction, maxDistance);
+        const r = raycastInternal(origin, direction, maxDistance, void 0, false, true);
         return r ? { object: r.object, part: r.part, point: r.point, normal: r.normal, distance: r.distance } : null;
       },
       sweepBox(box, direction, distance, options2 = {}) {
@@ -5672,21 +5872,23 @@ var GameDestruction = (() => {
       },
       shoot(origin, direction, energy, caliber, source, round) {
         const extras = typeof round === "number" ? { piercing: round } : round ?? {};
-        return withCollapses(run(() => {
+        return withCollapses(run(withBlow("ballistic", () => {
           const results = [];
           const d = vec.normalize(direction);
           const ignore = /* @__PURE__ */ new Set();
           let org = origin;
           let E = energy;
           for (let i = 0; i < 4 && E > 0; i++) {
-            const rh = raycastInternal(org, d, Infinity, ignore);
+            const rh = raycastInternal(org, d, Infinity, ignore, false, true);
             if (!rh) break;
             const im = impls.get(rh.object);
             if (im) {
-              const r = implHit(im, { type: "ballistic", point: rh.point, direction: d, energy: E, caliber, ...extras, ...source !== void 0 ? { source } : {} });
+              const scaled = extras.penetration && E < energy ? { ...extras, penetration: Object.fromEntries(Object.entries(extras.penetration).map(([k, mm]) => [k, mm * (E / energy)])) } : extras;
+              const r = implHit(im, { type: "ballistic", point: rh.point, part: rh.part, normal: rh.normal, direction: d, energy: E, caliber, ...scaled, ...source !== void 0 ? { source } : {} });
               r.part = rh.part;
               r.point = rh.point;
-              r.exitEnergy = r.penetrated ? E * 0.5 : 0;
+              const left = r.events.find((e) => e.type === "hole" && e.energyLeft !== void 0);
+              r.exitEnergy = r.penetrated ? left?.energyLeft ?? E * 0.5 : 0;
               results.push(r);
               ignore.add(`${im.impl.id}\0${rh.part}`);
               if (!r.penetrated) break;
@@ -5705,7 +5907,7 @@ var GameDestruction = (() => {
             E = out.exitEnergy;
           }
           return results;
-        }));
+        })));
       },
       disassemble(objectId, jointId, tool, dt) {
         const im = impls.get(objectId);
@@ -6009,17 +6211,34 @@ var GameDestruction = (() => {
   ];
 
   // src/assemblies.ts
+  var SHIPPED = structuredClone(assemblies_default);
   var ASSEMBLIES = assemblies_default;
-  var registerAssembly = (def) => {
-    const at = ASSEMBLIES.findIndex((a) => a.id === def.id);
-    if (at >= 0) ASSEMBLIES[at] = def;
-    else ASSEMBLIES.push(def);
+  var assembliesOver = (defs) => {
+    const get = (id) => defs.find((a) => a.id === id);
+    return {
+      list: () => defs,
+      get,
+      register(def) {
+        const at = defs.findIndex((a) => a.id === def.id);
+        if (at >= 0) defs[at] = def;
+        else defs.push(def);
+      },
+      part: (assemblyId, options) => buildAssemblyPart(get(assemblyId), assemblyId, options)
+    };
+  };
+  var createAssemblies = (options = {}) => {
+    const entries = mergeById(SHIPPED.map((def) => structuredClone(def)), (options.packs ?? []).flat());
+    applyPatches(entries, options.patch);
+    removeIds(entries, options.remove);
+    return assembliesOver([...entries.values()]);
   };
-  var getAssembly = (id) => ASSEMBLIES.find((a) => a.id === id);
+  var defaultSet;
+  var defaultAssemblies = () => defaultSet ?? (defaultSet = assembliesOver(ASSEMBLIES));
+  var registerAssembly = (def) => defaultAssemblies().register(def);
+  var getAssembly = (id) => defaultAssemblies().get(id);
   var faceCount = (layer) => layer.faces === "both" ? 2 : 1;
   var assemblyDepth = (def) => def.depth ?? def.core.thickness + (def.layers ?? []).reduce((sum, l) => sum + l.thickness * faceCount(l), 0);
-  var assemblyPart = (assemblyId, options) => {
-    const def = getAssembly(assemblyId);
+  var buildAssemblyPart = (def, assemblyId, options) => {
     if (!def) throw new Error(`unknown assembly "${assemblyId}"`);
     const densityOf = (id) => {
       const m = options.materials?.get(id) ?? MATERIALS.find((x) => x.id === id);
@@ -6046,6 +6265,7 @@ var GameDestruction = (() => {
       ...options.extra
     };
   };
+  var assemblyPart = (assemblyId, options) => defaultAssemblies().part(assemblyId, options);
 
   // src/frame.ts
   var buildFrame = (o = {}) => {
@@ -6483,7 +6703,7 @@ var GameDestruction = (() => {
 
   // src/contracts.ts
   var checkDestructible2 = (impl, options = {}) => {
-    const contractOptions = { materials: [...MATERIALS.map((m) => m.id), ...options.materials ?? []] };
+    const contractOptions = { materials: [...MATERIALS.map((m) => m.id), ...options.materials ?? []], ...options.cost === void 0 ? {} : { cost: options.cost } };
     return checkDestructible(impl, contractOptions);
   };
   return __toCommonJS(index_exports);