@classytic/stage 0.1.0

package/dist/scene/resolve.mjs

@@ -0,0 +1,95 @@
+import { isDerived, isVec2 } from "./types.mjs";
+import { parentIds } from "./schema.mjs";
+import { EVALUATORS } from "./evaluators.mjs";
+
+//#region src/scene/resolve.ts
+function bindingParents(bindings) {
+	const m = /* @__PURE__ */ new Map();
+	for (const b of bindings) {
+		const list = m.get(b.from.ref) ?? [];
+		list.push(b.to.ref);
+		m.set(b.from.ref, list);
+	}
+	return m;
+}
+function resolve(doc, overlay, prev, simStates) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const el of doc.elements) byId.set(el.id, el);
+	const bindEdges = bindingParents(doc.bindings ?? []);
+	const parentsOf = (el) => {
+		const refParents = parentIds(el);
+		const binds = bindEdges.get(el.id) ?? [];
+		return [...refParents, ...binds].filter((id) => byId.has(id));
+	};
+	const indeg = /* @__PURE__ */ new Map();
+	const children = /* @__PURE__ */ new Map();
+	for (const el of doc.elements) {
+		const ps = parentsOf(el);
+		indeg.set(el.id, ps.length);
+		for (const p of ps) {
+			const cs = children.get(p) ?? [];
+			cs.push(el.id);
+			children.set(p, cs);
+		}
+	}
+	const queue = [];
+	for (const el of doc.elements) if ((indeg.get(el.id) ?? 0) === 0) queue.push(el.id);
+	const order = [];
+	while (queue.length) {
+		const id = queue.shift();
+		order.push(id);
+		for (const c of children.get(id) ?? []) {
+			const n = (indeg.get(c) ?? 0) - 1;
+			indeg.set(c, n);
+			if (n === 0) queue.push(c);
+		}
+	}
+	const values = /* @__PURE__ */ new Map();
+	const errors = {};
+	const inOrder = new Set(order);
+	for (const el of doc.elements) if (!inOrder.has(el.id)) errors[el.id] = "cycle";
+	const ctx = {
+		get: (r) => values.get(r.ref),
+		vec: (r) => {
+			const v = values.get(r.ref);
+			return isVec2(v) ? v : void 0;
+		},
+		num: (x) => typeof x === "number" ? x : numOfVal(values.get(x.ref)),
+		prevVal: (id) => prev?.values.get(id),
+		simField: (sim, field) => simStates?.get(sim)?.[field],
+		selfId: ""
+	};
+	for (const id of order) {
+		const el = byId.get(id);
+		if (!el) continue;
+		try {
+			if (isDerived(el)) {
+				const evalFn = EVALUATORS[el.def.op];
+				if (!evalFn) throw new Error(`no evaluator for op '${el.def.op}'`);
+				ctx.selfId = id;
+				values.set(id, evalFn(el.def, ctx));
+			} else if (el.kind === "point") {
+				const o = overlay?.get(id);
+				values.set(id, isVec2(o) ? o : el.free.at);
+			} else if (el.kind === "scalar") {
+				const o = overlay?.get(id);
+				values.set(id, typeof o === "number" ? o : el.free.value);
+			} else if (el.kind === "note") values.set(id, el.free.at);
+		} catch (e) {
+			errors[id] = e instanceof Error ? e.message : String(e);
+		}
+	}
+	return {
+		values,
+		order,
+		errors
+	};
+}
+function numOfVal(v) {
+	if (typeof v === "number") return v;
+	if (typeof v === "boolean") return v ? 1 : 0;
+	return NaN;
+}
+
+//#endregion
+export { resolve };

package/dist/scene/schema.d.mts

@@ -0,0 +1,9 @@
+import { DerivedDef, Id, Op, Ref, SceneElement } from "./types.mjs";
+
+//#region src/scene/schema.d.ts
+declare function isRef(x: unknown): x is Ref;
+declare const OP_REFS: Record<Op, (def: DerivedDef) => Ref[]>;
+/** Parent element ids of `el` from its def's declared Refs (free elements have none). */
+declare function parentIds(el: SceneElement): Id[];
+//#endregion
+export { OP_REFS, isRef, parentIds };

package/dist/scene/schema.mjs

@@ -0,0 +1,51 @@
+import { isDerived } from "./types.mjs";
+
+//#region src/scene/schema.ts
+function isRef(x) {
+	return !!x && typeof x === "object" && "ref" in x && typeof x.ref === "string";
+}
+const refsOnly = (...xs) => xs.filter(isRef);
+const OP_REFS = {
+	midpoint: (d) => d.of,
+	intersect: (d) => d.of,
+	circle: (d) => {
+		const x = d;
+		return refsOnly(x.center, x.through);
+	},
+	line: (d) => d.through,
+	segment: (d) => {
+		const x = d;
+		return [x.from, x.to];
+	},
+	polygon: (d) => d.vertices,
+	distance: (d) => d.of,
+	angle: (d) => d.of,
+	linop: (d) => d.terms.map((t) => t.in),
+	clamp: (d) => [d.in],
+	lerp: (d) => {
+		const x = d;
+		return refsOnly(x.a, x.b, x.t);
+	},
+	reduce: (d) => d.inputs,
+	product: (d) => d.of,
+	compare: (d) => {
+		const x = d;
+		return refsOnly(x.a, x.b);
+	},
+	select: (d) => {
+		const x = d;
+		return refsOnly(x.cond, x.then, x.else);
+	},
+	expr: (d) => Object.values(d.inputs),
+	asset: (d) => Object.values(d.bind)
+};
+/** Parent element ids of `el` from its def's declared Refs (free elements have none). */
+function parentIds(el) {
+	if (!isDerived(el)) return [];
+	const extract = OP_REFS[el.def.op];
+	if (!extract) return [];
+	return extract(el.def).map((r) => r.ref);
+}
+
+//#endregion
+export { OP_REFS, isRef, parentIds };

package/dist/scene/sims.d.mts

@@ -0,0 +1,18 @@
+import { Id, SimDecl } from "./types.mjs";
+
+//#region src/scene/sims.d.ts
+/** Live per-instance core state, keyed by SimDecl.id. */
+type SimStates = Map<Id, Record<string, unknown>>;
+/** Seed each declared core from its params. */
+declare function initSims(decls: SimDecl[]): SimStates;
+/**
+ * Advance every core by `dtSec` and collect the scalar overlay its `drives` map
+ * produces. Returns fresh states (treat the input as immutable) + the overlay.
+ */
+declare function stepSims(decls: SimDecl[], prev: SimStates, dtSec: number): {
+  states: SimStates;
+  scalars: Map<Id, number>;
+  done: boolean;
+};
+//#endregion
+export { SimStates, initSims, stepSims };

package/dist/scene/sims.mjs

@@ -0,0 +1,54 @@
+import { getSim } from "../sim/registry.mjs";
+
+//#region src/scene/sims.ts
+/**
+* Sim runtime for a SceneDoc. A `SimDecl` (in doc.meta.sims) names a registered
+* core + its params, and maps the core's output fields → `scalar` element ids.
+* Each frame the runtime steps every core and produces a scalar overlay; `<Scene>`
+* feeds that overlay into `resolve()` exactly like a drag override, so the pure
+* resolver re-evaluates the DAG with the live values. Time lives here; the
+* resolver stays a pure function of its inputs.
+*
+* Non-finite outputs (NaN/Inf from a diverging core) are dropped, not propagated
+* (graceful failure — a bad sim never blanks the canvas).
+*/
+/** Seed each declared core from its params. */
+function initSims(decls) {
+	const states = /* @__PURE__ */ new Map();
+	for (const d of decls) {
+		const core = getSim(d.core);
+		if (core) states.set(d.id, core.reset(d.params ?? {}));
+	}
+	return states;
+}
+/**
+* Advance every core by `dtSec` and collect the scalar overlay its `drives` map
+* produces. Returns fresh states (treat the input as immutable) + the overlay.
+*/
+function stepSims(decls, prev, dtSec) {
+	const states = /* @__PURE__ */ new Map();
+	const scalars = /* @__PURE__ */ new Map();
+	for (const d of decls) {
+		const core = getSim(d.core);
+		const before = prev.get(d.id);
+		if (!core || !before) continue;
+		const merged = d.params ? {
+			...before,
+			...d.params
+		} : before;
+		const after = core.step(merged, dtSec);
+		states.set(d.id, after);
+		for (const [elId, field] of Object.entries(d.drives)) {
+			const v = after[field];
+			if (typeof v === "number" && Number.isFinite(v)) scalars.set(elId, v);
+		}
+	}
+	return {
+		states,
+		scalars,
+		done: decls.length > 0 && decls.every((d) => states.get(d.id)?.done === true)
+	};
+}
+
+//#endregion
+export { initSims, stepSims };

package/dist/scene/store.d.mts

@@ -0,0 +1,22 @@
+import { Vec2 } from "../core/vec.mjs";
+import { Id, SceneDoc } from "./types.mjs";
+import { Command } from "./commands.mjs";
+import { Resolved } from "./resolve.mjs";
+
+//#region src/scene/store.d.ts
+interface InstanceState {
+  selection: ReadonlySet<Id>;
+  hover: Id | null;
+  dragOverlay: ReadonlyMap<Id, Vec2>;
+}
+declare class SceneStore {
+  readonly doc: SceneDoc;
+  readonly instance: InstanceState;
+  constructor(doc: SceneDoc, instance?: InstanceState);
+  static from(raw: unknown): SceneStore;
+  apply(cmd: Command): SceneStore;
+  withInstance(patch: Partial<InstanceState>): SceneStore;
+  resolve(prev?: Resolved): Resolved;
+}
+//#endregion
+export { InstanceState, SceneStore };

package/dist/scene/store.mjs

@@ -0,0 +1,37 @@
+import { resolve } from "./resolve.mjs";
+import { applyCommand } from "./commands.mjs";
+import { migrate } from "./migrate.mjs";
+
+//#region src/scene/store.ts
+const EMPTY_INSTANCE = {
+	selection: /* @__PURE__ */ new Set(),
+	hover: null,
+	dragOverlay: /* @__PURE__ */ new Map()
+};
+var SceneStore = class SceneStore {
+	doc;
+	instance;
+	constructor(doc, instance = EMPTY_INSTANCE) {
+		this.doc = doc;
+		this.instance = instance;
+	}
+	static from(raw) {
+		return new SceneStore(migrate(raw));
+	}
+	apply(cmd) {
+		return new SceneStore(applyCommand(this.doc, cmd), this.instance);
+	}
+	withInstance(patch) {
+		return new SceneStore(this.doc, {
+			...this.instance,
+			...patch
+		});
+	}
+	resolve(prev) {
+		const overlay = this.instance.dragOverlay.size ? this.instance.dragOverlay : void 0;
+		return resolve(this.doc, overlay, prev);
+	}
+};
+
+//#endregion
+export { SceneStore };

package/dist/scene/types.d.mts

@@ -0,0 +1,228 @@
+import { Vec2 } from "../core/vec.mjs";
+import { ViewBox } from "../core/coords.mjs";
+
+//#region src/scene/types.d.ts
+type Id = string;
+/** Explicit parent-edge wrapper. A bare string is never an edge. */
+interface Ref {
+  ref: Id;
+}
+type NumOrRef = number | Ref;
+/** Structured geometry value an asset resolver computes (single source of truth). */
+interface AssetGeometry {
+  kind: 'asset-geom';
+  parts: Record<string, Vec2 | Vec2[] | number>;
+  meta?: Record<string, unknown>;
+}
+interface CircleVal {
+  kind: 'circle';
+  center: Vec2;
+  r: number;
+}
+interface ShapeLineVal {
+  kind: 'line' | 'segment';
+  a: Vec2;
+  b: Vec2;
+}
+/** A resolved element's value. */
+type Val = number | boolean | string | Vec2 | Vec2[] | CircleVal | ShapeLineVal | AssetGeometry;
+interface ElementStyle {
+  color?: string;
+  fill?: string;
+  opacity?: number;
+  weight?: number;
+  dashed?: boolean;
+  hidden?: boolean;
+  layer?: number;
+}
+interface ElementBase {
+  id: Id;
+  label?: string;
+  style?: ElementStyle;
+  a11y?: {
+    role?: string;
+    label?: string;
+  };
+  meta?: Record<string, unknown>;
+}
+interface FreePoint extends ElementBase {
+  kind: 'point';
+  free: {
+    at: Vec2;
+    draggable?: boolean;
+    constrain?: 'horizontal' | 'vertical' | {
+      onLine: Ref;
+    };
+  };
+}
+interface FreeScalar extends ElementBase {
+  kind: 'scalar';
+  free: {
+    value: number;
+    min?: number;
+    max?: number;
+    step?: number;
+  };
+}
+interface FreeNote extends ElementBase {
+  kind: 'note';
+  free: {
+    at: Vec2;
+    text: string;
+  };
+}
+type FreeElement = FreePoint | FreeScalar | FreeNote;
+type DerivedDef = {
+  op: 'midpoint';
+  of: [Ref, Ref];
+} | {
+  op: 'intersect';
+  of: [Ref, Ref];
+  pick?: 0 | 1;
+} | {
+  op: 'circle';
+  center: Ref;
+  radius?: number;
+  through?: Ref;
+} | {
+  op: 'line';
+  through: [Ref, Ref];
+} | {
+  op: 'segment';
+  from: Ref;
+  to: Ref;
+} | {
+  op: 'polygon';
+  vertices: Ref[];
+} | {
+  op: 'distance';
+  of: [Ref, Ref];
+} | {
+  op: 'angle';
+  of: [Ref, Ref, Ref];
+} | {
+  op: 'linop';
+  terms: {
+    coef: number;
+    in: Ref;
+  }[];
+  const?: number;
+} | {
+  op: 'clamp';
+  in: Ref;
+  min: number;
+  max: number;
+} | {
+  op: 'lerp';
+  a: Ref;
+  b: Ref;
+  t: NumOrRef;
+} | {
+  op: 'reduce';
+  inputs: Ref[];
+  reducer: 'sum' | 'mean' | 'max' | 'min';
+} | {
+  op: 'product';
+  of: [Ref, Ref];
+} | {
+  op: 'compare';
+  a: Ref;
+  b: NumOrRef;
+  cmp: 'lt' | 'le' | 'eq' | 'ge' | 'gt';
+  eps?: number;
+} | {
+  op: 'select';
+  cond: Ref;
+  then: NumOrRef;
+  else: NumOrRef;
+} | {
+  op: 'expr';
+  inputs: Record<string, Ref>;
+  fn: string;
+} | {
+  op: 'asset';
+  asset: string;
+  params: Record<string, number | Vec2>;
+  bind: Record<string, Ref>;
+  simBind?: Record<string, {
+    sim: Id;
+    field: string;
+  }>;
+};
+type Op = DerivedDef['op'];
+type DerivedKind = 'point' | 'circle' | 'line' | 'segment' | 'polygon' | 'measure' | 'scalar' | 'boolean' | 'asset';
+interface DerivedElement extends ElementBase {
+  kind: DerivedKind;
+  def: DerivedDef;
+}
+type SceneElement = FreeElement | DerivedElement;
+/** First-class relation record (ids only, never literals). */
+interface Binding {
+  id: Id;
+  from: Ref;
+  to: Ref;
+  rel: string;
+  props?: Record<string, unknown>;
+}
+/**
+ * Structured pedagogy for a lab — first-class learning data, NOT prose buried in
+ * UI text. Authored alongside the scene, surfaced to the learner seam + xAPI.
+ */
+interface LabMeta {
+  /** Learning objectives this lab evidences (ids or short statements). */
+  objectives?: string[];
+  /** Known misconceptions: an optional trigger (a state that exposes it) + the note. */
+  misconceptions?: {
+    trigger?: string;
+    note: string;
+  }[];
+  /** Progressive hints, revealed in order. */
+  hints?: string[];
+  /** 1 (intro) … 5 (challenge). */
+  difficulty?: 1 | 2 | 3 | 4 | 5;
+  /** Prerequisite lab/objective ids. */
+  prerequisites?: string[];
+  /** Human-readable success criterion (what "solved" means). */
+  successCriteria?: string;
+}
+/**
+ * A time-stepped sim wired into a scene: a registered core advances each frame and
+ * its named output fields drive `scalar` elements (by id) as external inputs — so
+ * the pure resolver re-evaluates with live values without knowing about time.
+ */
+interface SimDecl {
+  /** Instance id (unique within the doc). */
+  id: Id;
+  /** Registered sim-core name (e.g. 'wave'). */
+  core: string;
+  /** Seed params for the core's reset() (e.g. a sampler's `weights` array, a
+   *  particle box `{w,h}`). */
+  params?: Record<string, number | string | boolean | number[] | Record<string, number>>;
+  /** Map: scalar-element id → core-state field that feeds it. */
+  drives: Record<Id, string>;
+}
+/** SceneDoc.meta — `pedagogy` + `sims` are typed; the rest stays open for domain use. */
+type SceneMeta = {
+  pedagogy?: LabMeta;
+  sims?: SimDecl[];
+} & Record<string, unknown>;
+/** Canonical persisted form. `commands[]` is NOT stored — history lives in the Editor. */
+interface SceneDoc {
+  schemaVersion: 2;
+  type: 'stage-scene';
+  view?: ViewBox;
+  width?: number;
+  height?: number;
+  elements: SceneElement[];
+  bindings: Binding[];
+  meta?: SceneMeta;
+}
+declare function isFree(el: SceneElement): el is FreeElement;
+declare function isDerived(el: SceneElement): el is DerivedElement;
+declare function isVec2(v: Val | undefined): v is Vec2;
+declare function isCircleVal(v: Val | undefined): v is CircleVal;
+declare function isLineVal(v: Val | undefined): v is ShapeLineVal;
+declare function isAssetGeom(v: Val | undefined): v is AssetGeometry;
+declare function numOf(v: Val | undefined): number;
+//#endregion
+export { AssetGeometry, Binding, CircleVal, DerivedDef, DerivedElement, DerivedKind, ElementBase, ElementStyle, FreeElement, FreeNote, FreePoint, FreeScalar, Id, LabMeta, NumOrRef, Op, Ref, SceneDoc, SceneElement, SceneMeta, ShapeLineVal, SimDecl, Val, isAssetGeom, isCircleVal, isDerived, isFree, isLineVal, isVec2, numOf };

package/dist/scene/types.mjs

@@ -0,0 +1,27 @@
+//#region src/scene/types.ts
+function isFree(el) {
+	return "free" in el;
+}
+function isDerived(el) {
+	return "def" in el;
+}
+function isVec2(v) {
+	return !!v && typeof v === "object" && "x" in v && "y" in v && !("kind" in v);
+}
+function isCircleVal(v) {
+	return !!v && typeof v === "object" && "kind" in v && v.kind === "circle";
+}
+function isLineVal(v) {
+	return !!v && typeof v === "object" && "kind" in v && (v.kind === "line" || v.kind === "segment");
+}
+function isAssetGeom(v) {
+	return !!v && typeof v === "object" && "kind" in v && v.kind === "asset-geom";
+}
+function numOf(v) {
+	if (typeof v === "number") return v;
+	if (typeof v === "boolean") return v ? 1 : 0;
+	return NaN;
+}
+
+//#endregion
+export { isAssetGeom, isCircleVal, isDerived, isFree, isLineVal, isVec2, numOf };

package/dist/sim/equilibrium.d.mts

@@ -0,0 +1,36 @@
+import { SimCore } from "./types.mjs";
+
+//#region src/sim/equilibrium.d.ts
+interface RxnSpecies {
+  name: string;
+  /** Stoichiometric coefficient (positive). */
+  coeff: number;
+  /** Which side of the equation. */
+  side: 'reactant' | 'product';
+  /** Optional colour token (for a coloured-reaction skin). */
+  color?: string;
+}
+interface EquilibriumParams {
+  species: RxnSpecies[];
+  /** Initial concentrations aligned to `species`. Named conc0 (NOT conc) so the
+   *  runtime's per-frame param-merge can't reset the evolving concentrations. */
+  conc0: number[];
+  /** Forward / reverse rate constants. Live-mergeable (raise/lower to model a
+   *  temperature change, which shifts K = k_f/k_r). */
+  kf: number;
+  kr: number;
+}
+interface EquilibriumState {
+  spec: RxnSpecies[];
+  conc: number[];
+  kf: number;
+  kr: number;
+  tSec: number;
+  /** Reaction quotient Π[product]^b / Π[reactant]^a (→ K at equilibrium). */
+  Q: number;
+  /** Equilibrium constant k_f/k_r. */
+  K: number;
+}
+declare const EquilibriumCore: SimCore<EquilibriumState, EquilibriumParams>;
+//#endregion
+export { EquilibriumCore, EquilibriumParams, EquilibriumState, RxnSpecies };

package/dist/sim/equilibrium.mjs

@@ -0,0 +1,54 @@
+//#region src/sim/equilibrium.ts
+const prod = (state, side) => {
+	let p = 1;
+	for (let i = 0; i < state.spec.length; i++) if (state.spec[i].side === side) p *= Math.max(0, state.conc[i]) ** state.spec[i].coeff;
+	return p;
+};
+const quotient = (state) => {
+	const denom = prod(state, "reactant");
+	return denom <= 1e-9 ? Infinity : prod(state, "product") / denom;
+};
+const EquilibriumCore = {
+	reset(params) {
+		const conc = params.conc0.map((c) => Math.max(0, c));
+		const base = {
+			spec: params.species,
+			conc
+		};
+		return {
+			spec: params.species,
+			conc,
+			kf: params.kf,
+			kr: params.kr,
+			tSec: 0,
+			Q: quotient(base),
+			K: params.kr > 0 ? params.kf / params.kr : Infinity
+		};
+	},
+	step(state, dtSec) {
+		const dt = Math.max(0, dtSec);
+		const dxiRaw = (state.kf * prod(state, "reactant") - state.kr * prod(state, "product")) * dt;
+		let maxXi = Math.abs(dxiRaw);
+		for (let i = 0; i < state.spec.length; i++) {
+			const s = state.spec[i];
+			if (s.side === "reactant" && dxiRaw > 0 || s.side === "product" && dxiRaw < 0) maxXi = Math.min(maxXi, state.conc[i] / s.coeff);
+		}
+		const dxi = Math.sign(dxiRaw) * Math.min(Math.abs(dxiRaw), maxXi);
+		const conc = state.conc.map((c, i) => {
+			const s = state.spec[i];
+			const delta = (s.side === "reactant" ? -1 : 1) * s.coeff * dxi;
+			return Math.max(0, c + delta);
+		});
+		const next = {
+			...state,
+			conc,
+			tSec: state.tSec + dt
+		};
+		next.Q = quotient(next);
+		next.K = state.kr > 0 ? state.kf / state.kr : Infinity;
+		return next;
+	}
+};
+
+//#endregion
+export { EquilibriumCore };

package/dist/sim/index.d.mts

@@ -0,0 +1,9 @@
+import { SimCore } from "./types.mjs";
+import { WaveCore, WaveMode, WaveParams, WaveState } from "./wave.mjs";
+import { SamplerCore, SamplerParams, SamplerState } from "./sampler.mjs";
+import { RateCore, RateParams, RateState, halfLifeToTau, tauToHalfLife } from "./rate.mjs";
+import { Box, ParticlesCore, ParticlesParams, ParticlesState } from "./particles.mjs";
+import { ETHANOL, Phase, Substance, ThermalCore, ThermalParams, ThermalSeg, ThermalState, WATER, segLabel } from "./thermal.mjs";
+import { EquilibriumCore, EquilibriumParams, EquilibriumState, RxnSpecies } from "./equilibrium.mjs";
+import { getSim, listSims, registerSim } from "./registry.mjs";
+export { type Box, ETHANOL, EquilibriumCore, type EquilibriumParams, type EquilibriumState, ParticlesCore, type ParticlesParams, type ParticlesState, type Phase, RateCore, type RateParams, type RateState, type RxnSpecies, SamplerCore, type SamplerParams, type SamplerState, type SimCore, type Substance, ThermalCore, type ThermalParams, type ThermalSeg, type ThermalState, WATER, WaveCore, type WaveMode, type WaveParams, type WaveState, getSim, halfLifeToTau, listSims, registerSim, segLabel, tauToHalfLife };

package/dist/sim/index.mjs

@@ -0,0 +1,9 @@
+import { WaveCore } from "./wave.mjs";
+import { SamplerCore } from "./sampler.mjs";
+import { RateCore, halfLifeToTau, tauToHalfLife } from "./rate.mjs";
+import { ParticlesCore } from "./particles.mjs";
+import { ETHANOL, ThermalCore, WATER, segLabel } from "./thermal.mjs";
+import { EquilibriumCore } from "./equilibrium.mjs";
+import { getSim, listSims, registerSim } from "./registry.mjs";
+
+export { ETHANOL, EquilibriumCore, ParticlesCore, RateCore, SamplerCore, ThermalCore, WATER, WaveCore, getSim, halfLifeToTau, listSims, registerSim, segLabel, tauToHalfLife };