@pibbl/core 0.0.1

package/dist/features/particles/lib/flow/population.js

@@ -0,0 +1,104 @@
+const CHUNK = 256;
+const NO_SLOT = 4294967295;
+const MAX_STEP_MILLISECONDS = 1e3 / 60;
+class FlowParticlePopulation2D {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.positions = new Float32Array(capacity * 2);
+    this.retired = new Uint8Array(capacity);
+    this.identities = new Float64Array(capacity).fill(-1);
+    this.times = new Float64Array(capacity);
+    this.birthTimes = new Float64Array(capacity);
+  }
+  capacity;
+  positions;
+  retired;
+  identities;
+  times;
+  birthTimes;
+  slots = new Uint32Array(CHUNK);
+  points = new Float32Array(CHUNK * 2);
+  midpoints = new Float32Array(CHUNK * 2);
+  velocities = new Float32Array(CHUNK * 2);
+  durations = new Float64Array(CHUNK);
+  copyFrom(other) {
+    this.positions.set(other.positions);
+    this.retired.set(other.retired);
+    this.identities.set(other.identities);
+    this.times.set(other.times);
+    this.birthTimes.set(other.birthTimes);
+  }
+  clear() {
+    this.identities.fill(-1);
+    this.retired.fill(0);
+  }
+  isRetired(slot) {
+    return this.retired[slot] === 1;
+  }
+  hasBirth(slot, identity, birthTime) {
+    return this.identities[slot] === identity && this.birthTimes[slot] === birthTime;
+  }
+  birth(slot, identity, time, x, y) {
+    this.retired[slot] = 0;
+    this.identities[slot] = identity;
+    this.birthTimes[slot] = this.times[slot] = time;
+    this.positions[slot * 2] = x;
+    this.positions[slot * 2 + 1] = y;
+  }
+  advance(field, firstSlot, ageOrder, liveCount, time) {
+    let slot = firstSlot, visited = 0;
+    while (slot !== NO_SLOT && visited < liveCount) {
+      let count = 0;
+      while (slot !== NO_SLOT && visited < liveCount && count < CHUNK) {
+        if (this.retired[slot] || field.isSolid(this.positions[slot * 2], this.positions[slot * 2 + 1])) {
+          this.retired[slot] = 1;
+          this.times[slot] = time;
+          slot = ageOrder[slot];
+          visited++;
+          continue;
+        }
+        this.slots[count] = slot;
+        this.points[count * 2] = this.positions[slot * 2];
+        this.points[count * 2 + 1] = this.positions[slot * 2 + 1];
+        this.durations[count] = Math.min(MAX_STEP_MILLISECONDS * 4, Math.max(0, time - this.times[slot]));
+        this.times[slot] = time;
+        slot = ageOrder[slot];
+        visited++;
+        count++;
+      }
+      for (let step = 0; step < 4; step++) {
+        let active = false;
+        for (let i = 0; i < count; i++) if (this.durations[i] > 0) {
+          active = true;
+          break;
+        }
+        if (!active) break;
+        field.sampleBatch(this.points, this.velocities, count);
+        for (let i = 0; i < count; i++) {
+          const seconds = Math.min(MAX_STEP_MILLISECONDS, this.durations[i]) / 1e3;
+          this.velocities[i * 2] *= seconds;
+          this.velocities[i * 2 + 1] *= seconds;
+        }
+        this.midpoints.set(this.points);
+        field.moveBatch(this.midpoints, this.velocities, count, 0.5);
+        field.sampleBatch(this.midpoints, this.velocities, count);
+        for (let i = 0; i < count; i++) {
+          const milliseconds = Math.min(MAX_STEP_MILLISECONDS, this.durations[i]);
+          this.durations[i] -= milliseconds;
+          this.velocities[i * 2] *= milliseconds / 1e3;
+          this.velocities[i * 2 + 1] *= milliseconds / 1e3;
+        }
+        field.moveBatch(this.points, this.velocities, count, 1);
+      }
+      for (let i = 0; i < count; i++) {
+        const target = this.slots[i] * 2;
+        this.positions[target] = this.points[i * 2];
+        this.positions[target + 1] = this.points[i * 2 + 1];
+      }
+    }
+  }
+}
+export {
+  FlowParticlePopulation2D
+};
+//# sourceMappingURL=population.js.map

package/dist/features/particles/lib/flow/population.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/features/particles/lib/flow/population.ts"],
+  "sourcesContent": ["import type { FlowFieldKernel2D } from \"./field.js\";\nconst CHUNK = 256;\nconst NO_SLOT = 0xffffffff;\nconst MAX_STEP_MILLISECONDS = 1000 / 60;\n\n/** Persistent particle positions, independent of Canvas and physics bodies.\n * RK2 integration samples a shared field in bounded chunks. Birth identities\n * let recycled ledger slots initialize without allocating particle objects.\n */\nexport class FlowParticlePopulation2D {\n  readonly positions: Float32Array;\n  private readonly retired: Uint8Array;\n  private readonly identities: Float64Array;\n  private readonly times: Float64Array;\n  private readonly birthTimes: Float64Array;\n  private readonly slots = new Uint32Array(CHUNK);\n  private readonly points = new Float32Array(CHUNK * 2);\n  private readonly midpoints = new Float32Array(CHUNK * 2);\n  private readonly velocities = new Float32Array(CHUNK * 2);\n  private readonly durations = new Float64Array(CHUNK);\n  constructor(readonly capacity: number) {\n    this.positions = new Float32Array(capacity * 2);\n    this.retired = new Uint8Array(capacity);\n    this.identities = new Float64Array(capacity).fill(-1);\n    this.times = new Float64Array(capacity);\n    this.birthTimes = new Float64Array(capacity);\n  }\n  copyFrom(other: FlowParticlePopulation2D): void {\n    this.positions.set(other.positions);\n    this.retired.set(other.retired);\n    this.identities.set(other.identities);\n    this.times.set(other.times);\n    this.birthTimes.set(other.birthTimes);\n  }\n  clear(): void { this.identities.fill(-1); this.retired.fill(0); }\n  isRetired(slot: number): boolean { return this.retired[slot] === 1; }\n  hasBirth(slot: number, identity: number, birthTime: number): boolean {\n    return this.identities[slot] === identity && this.birthTimes[slot] === birthTime;\n  }\n  birth(slot: number, identity: number, time: number, x: number, y: number): void {\n    this.retired[slot] = 0;\n    this.identities[slot] = identity;\n    this.birthTimes[slot] = this.times[slot] = time;\n    this.positions[slot * 2] = x;\n    this.positions[slot * 2 + 1] = y;\n  }\n  advance(field: FlowFieldKernel2D, firstSlot: number, ageOrder: Uint32Array, liveCount: number, time: number): void {\n    let slot = firstSlot, visited = 0;\n    while (slot !== NO_SLOT && visited < liveCount) {\n      let count = 0;\n      while (slot !== NO_SLOT && visited < liveCount && count < CHUNK) {\n        if (this.retired[slot] || field.isSolid(this.positions[slot * 2]!, this.positions[slot * 2 + 1]!)) {\n          this.retired[slot] = 1;\n          this.times[slot] = time;\n          slot = ageOrder[slot]!;\n          visited++;\n          continue;\n        }\n        this.slots[count] = slot;\n        this.points[count * 2] = this.positions[slot * 2]!;\n        this.points[count * 2 + 1] = this.positions[slot * 2 + 1]!;\n        this.durations[count] = Math.min(MAX_STEP_MILLISECONDS * 4, Math.max(0, time - this.times[slot]!));\n        this.times[slot] = time;\n        slot = ageOrder[slot]!;\n        visited++;\n        count++;\n      }\n      // A fixed upper bound of four substeps, including fractional birth ages.\n      for (let step = 0; step < 4; step++) {\n        let active = false;\n        for (let i = 0; i < count; i++) if (this.durations[i]! > 0) { active = true; break; }\n        if (!active) break;\n        field.sampleBatch(this.points, this.velocities, count);\n        for (let i = 0; i < count; i++) {\n          const seconds = Math.min(MAX_STEP_MILLISECONDS, this.durations[i]!) / 1000;\n          this.velocities[i * 2] *= seconds;\n          this.velocities[i * 2 + 1] *= seconds;\n        }\n        this.midpoints.set(this.points);\n        field.moveBatch(this.midpoints, this.velocities, count, 0.5);\n        field.sampleBatch(this.midpoints, this.velocities, count);\n        for (let i = 0; i < count; i++) {\n          const milliseconds = Math.min(MAX_STEP_MILLISECONDS, this.durations[i]!);\n          this.durations[i] -= milliseconds;\n          this.velocities[i * 2] *= milliseconds / 1000;\n          this.velocities[i * 2 + 1] *= milliseconds / 1000;\n        }\n        field.moveBatch(this.points, this.velocities, count, 1);\n      }\n      for (let i = 0; i < count; i++) {\n        const target = this.slots[i]! * 2;\n        this.positions[target] = this.points[i * 2]!;\n        this.positions[target + 1] = this.points[i * 2 + 1]!;\n      }\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/features/particles/lib/particle.d.ts

@@ -0,0 +1,113 @@
+import type { PibblParticleChoice, PibblParticleCurve, PibblParticleCurveOptions, PibblParticleCurveValue, PibblParticleGradient, PibblParticleIntegerRange, PibblParticleParameterReference, PibblParticleRange } from './types.js';
+export type ParticleDescriptorRecord = Readonly<{
+    type: 'between';
+    min: number;
+    max: number;
+}> | Readonly<{
+    type: 'integer';
+    min: number;
+    max: number;
+}> | Readonly<{
+    type: 'choice';
+    choices: readonly Readonly<{
+        value: unknown;
+        weight: number;
+    }>[];
+}> | Readonly<{
+    type: 'parameter';
+    name: string;
+}> | Readonly<{
+    type: 'curve';
+    keys: readonly (readonly [number, PibblParticleCurveValue])[];
+    options: PibblParticleCurveOptions | undefined;
+}> | Readonly<{
+    type: 'gradient';
+    keys: readonly (readonly [number, string])[];
+    options: PibblParticleCurveOptions | undefined;
+}>;
+declare function between(min: number, max: number): PibblParticleRange;
+declare function integer(min: number, max: number): PibblParticleIntegerRange;
+declare function choice<const T>(choices: readonly Readonly<{
+    value: T;
+    weight: number;
+}>[]): PibblParticleChoice<T>;
+declare function parameter<const Name extends string>(name: Name): PibblParticleParameterReference<Name>;
+declare function curve<const T extends PibblParticleCurveValue>(keys: readonly (readonly [time: number, value: T])[], options?: PibblParticleCurveOptions): PibblParticleCurve<T>;
+declare function gradient(keys: readonly (readonly [time: number, color: string])[], options?: PibblParticleCurveOptions): PibblParticleGradient;
+/** @internal Returns metadata only for descriptors created by this package instance. */
+export declare function getParticleDescriptorRecord(value: unknown): ParticleDescriptorRecord | undefined;
+/**
+ * Describes a continuous random range for particle sampling.
+ *
+ * @param min - Finite lower bound, no greater than max.
+ * @param max - Finite upper bound; the span must also be finite.
+ * @returns An immutable continuous sampling descriptor. See {@link PibblParticleRange}.
+ *
+ * @see {@link PibblParticleRange}
+ */
+export declare const particleRange: typeof between;
+/**
+ * Describes a random integer range for particle sampling.
+ *
+ * @param min - Inclusive lower bound, a safe integer.
+ * @param max - Inclusive upper bound; the inclusive span must be a safe integer.
+ * @returns An immutable integer sampling descriptor. See {@link PibblParticleIntegerRange}.
+ *
+ * @see {@link PibblParticleIntegerRange}
+ */
+export declare const particleInteger: typeof integer;
+/**
+ * Describes weighted choices sampled by a particle effect.
+ *
+ * @param choices - Nonempty weighted values; every weight and their total must be positive and
+ * finite.
+ * @returns An immutable descriptor containing copied choices. See {@link PibblParticleChoice}.
+ *
+ * @see {@link PibblParticleChoice}
+ */
+export declare const particleChoice: typeof choice;
+/**
+ * References a named parameter declared by a particle effect.
+ *
+ * @param name - Nonempty name of a parameter declared by the effect.
+ * @returns A typed parameter reference. See {@link PibblParticleParameterReference}.
+ *
+ * @see {@link PibblParticleParameterReference}
+ */
+export declare const particleParameter: typeof parameter;
+/**
+ * Describes keyframed scalar or vector values over normalized particle lifetime.
+ *
+ * @param keys - Scalar or 2D-vector keys with strictly increasing normalized times, starting at 0
+ * and ending at 1.
+ * @param options - Optional segment easing. See {@link PibblParticleCurveOptions}.
+ * @returns An immutable lifetime curve containing copied keys. See {@link PibblParticleCurve}.
+ *
+ * @see {@link PibblParticleCurveOptions}
+ * @see {@link PibblParticleCurve}
+ * @see {@link PibblParticleCurveValue}
+ */
+export declare const particleCurve: typeof curve;
+/**
+ * Describes keyframed colors over normalized particle lifetime.
+ *
+ * @param keys - Color keys with strictly increasing normalized times, starting at 0 and ending at
+ * 1.
+ * @param options - Optional segment easing. See {@link PibblParticleCurveOptions}.
+ * @returns An immutable lifetime color gradient containing copied keys. See
+ * {@link PibblParticleGradient} .
+ *
+ * @see {@link PibblParticleCurveOptions}
+ * @see {@link PibblParticleGradient}
+ */
+export declare const particleGradient: typeof gradient;
+/** @internal Legacy test convenience; not exported from the public package entry. */
+export declare const particle: Readonly<{
+    between: typeof between;
+    integer: typeof integer;
+    choice: typeof choice;
+    parameter: typeof parameter;
+    curve: typeof curve;
+    gradient: typeof gradient;
+}>;
+export {};

package/dist/features/particles/lib/particle.js

@@ -0,0 +1,192 @@
+const descriptorRecords = /* @__PURE__ */ new WeakMap();
+function descriptor(value, record) {
+  const frozen = Object.freeze(value);
+  descriptorRecords.set(frozen, Object.freeze(record));
+  return frozen;
+}
+function assertFinite(value, label) {
+  if (!Number.isFinite(value)) {
+    throw new RangeError(`${label} must be finite; received ${String(value)}.`);
+  }
+}
+function cloneFrozenValue(value, seen = /* @__PURE__ */ new WeakMap()) {
+  if (value === null || typeof value !== "object") return value;
+  const existing = seen.get(value);
+  if (existing !== void 0) return existing;
+  if (Array.isArray(value)) {
+    const result2 = [];
+    seen.set(value, result2);
+    for (const entry of value) result2.push(cloneFrozenValue(entry, seen));
+    return Object.freeze(result2);
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return value;
+  const result = Object.create(prototype);
+  seen.set(value, result);
+  for (const [key, entry] of Object.entries(value)) {
+    result[key] = cloneFrozenValue(entry, seen);
+  }
+  return Object.freeze(result);
+}
+function validateRange(min, max, label) {
+  assertFinite(min, `${label} min`);
+  assertFinite(max, `${label} max`);
+  if (min > max) {
+    throw new RangeError(
+      `${label} bounds require min to be at most max; received ${String(min)} through ${String(max)}.`
+    );
+  }
+}
+function curveValueDimension(value) {
+  if (typeof value === "number") {
+    assertFinite(value, "particleCurve value");
+    return 1;
+  }
+  if (!Array.isArray(value) || value.length !== 2) {
+    throw new TypeError("particleCurve values must be finite numbers or two-dimensional vectors.");
+  }
+  assertFinite(value[0], "particleCurve vector value[0]");
+  assertFinite(value[1], "particleCurve vector value[1]");
+  return 2;
+}
+function validateKeyTimes(keys, label) {
+  if (keys.length === 0) throw new TypeError(`${label} keys must be nonempty.`);
+  if (keys[0]?.[0] !== 0 || keys.at(-1)?.[0] !== 1) {
+    throw new RangeError(`${label} keys must cover normalized time 0 through 1.`);
+  }
+  let previous = Number.NEGATIVE_INFINITY;
+  for (let index = 0; index < keys.length; index += 1) {
+    const time = keys[index]?.[0];
+    assertFinite(time, `${label} keys[${index}] time`);
+    if (time <= previous) {
+      throw new RangeError(`${label} key times must be strictly increasing.`);
+    }
+    previous = time;
+  }
+}
+function normalizeOptions(options, label) {
+  if (options === void 0) return void 0;
+  if (options.easing !== void 0 && typeof options.easing !== "function") {
+    throw new TypeError(`${label} options.easing must be a Pibbl easing function.`);
+  }
+  return Object.freeze({ easing: options.easing });
+}
+function between(min, max) {
+  validateRange(min, max, "particleRange");
+  if (!Number.isFinite(max - min)) {
+    throw new RangeError("particleRange span must be finite.");
+  }
+  const value = { type: "between", min, max };
+  return descriptor(value, value);
+}
+function integer(min, max) {
+  validateRange(min, max, "particleInteger");
+  if (!Number.isSafeInteger(min) || !Number.isSafeInteger(max)) {
+    throw new RangeError("particleInteger min and max must be safe integers.");
+  }
+  if (!Number.isSafeInteger(max - min + 1)) {
+    throw new RangeError("particleInteger inclusive span must be a safe integer.");
+  }
+  const value = { type: "integer", min, max };
+  return descriptor(value, value);
+}
+function choice(choices) {
+  if (choices.length === 0) {
+    throw new TypeError("particleChoice choices must be nonempty.");
+  }
+  let totalWeight = 0;
+  const copied = Object.freeze(choices.map(({ value: value2, weight }, index) => {
+    if (!Number.isFinite(weight) || weight <= 0) {
+      throw new RangeError(
+        `particleChoice choices[${index}].weight must be positive and finite; received ${String(weight)}.`
+      );
+    }
+    totalWeight += weight;
+    if (!Number.isFinite(totalWeight)) {
+      throw new RangeError("particleChoice total weight must be finite.");
+    }
+    return Object.freeze({ value: cloneFrozenValue(value2), weight });
+  }));
+  const value = { type: "choice", choices: copied };
+  return descriptor(value, value);
+}
+function parameter(name) {
+  if (typeof name !== "string" || name.trim().length === 0) {
+    throw new TypeError("particleParameter name must be a nonempty string.");
+  }
+  const value = { type: "parameter", name };
+  return descriptor(value, value);
+}
+function curve(keys, options) {
+  validateKeyTimes(keys, "particleCurve");
+  let dimension;
+  const copied = Object.freeze(keys.map(([time, value2], index) => {
+    const currentDimension = curveValueDimension(value2);
+    if (dimension !== void 0 && dimension !== currentDimension) {
+      throw new TypeError(
+        `particleCurve keys[${index}] value dimension must match earlier keys.`
+      );
+    }
+    dimension = currentDimension;
+    return Object.freeze([time, cloneFrozenValue(value2)]);
+  }));
+  const normalizedOptions = normalizeOptions(options, "particleCurve");
+  const value = {
+    type: "curve",
+    keys: copied,
+    ...normalizedOptions === void 0 ? {} : { options: normalizedOptions }
+  };
+  return descriptor(value, {
+    type: "curve",
+    keys: copied,
+    options: normalizedOptions
+  });
+}
+function gradient(keys, options) {
+  validateKeyTimes(keys, "particleGradient");
+  const copied = Object.freeze(keys.map(([time, color], index) => {
+    if (typeof color !== "string" || color.trim().length === 0) {
+      throw new TypeError(`particleGradient keys[${index}] color must be a nonempty string.`);
+    }
+    return Object.freeze([time, color]);
+  }));
+  const normalizedOptions = normalizeOptions(options, "particleGradient");
+  const value = {
+    type: "gradient",
+    keys: copied,
+    ...normalizedOptions === void 0 ? {} : { options: normalizedOptions }
+  };
+  return descriptor(value, {
+    type: "gradient",
+    keys: copied,
+    options: normalizedOptions
+  });
+}
+function getParticleDescriptorRecord(value) {
+  return typeof value === "object" && value !== null ? descriptorRecords.get(value) : void 0;
+}
+const particleRange = between;
+const particleInteger = integer;
+const particleChoice = choice;
+const particleParameter = parameter;
+const particleCurve = curve;
+const particleGradient = gradient;
+const particle = Object.freeze({
+  between,
+  integer,
+  choice,
+  parameter,
+  curve,
+  gradient
+});
+export {
+  getParticleDescriptorRecord,
+  particle,
+  particleChoice,
+  particleCurve,
+  particleGradient,
+  particleInteger,
+  particleParameter,
+  particleRange
+};
+//# sourceMappingURL=particle.js.map

package/dist/features/particles/lib/particle.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/particles/lib/particle.ts"],
+  "sourcesContent": ["import type {\n  PibblParticleChoice,\n  PibblParticleCurve,\n  PibblParticleCurveOptions,\n  PibblParticleCurveValue,\n  PibblParticleGradient,\n  PibblParticleIntegerRange,\n  PibblParticleParameterReference,\n  PibblParticleRange,\n} from './types.js';\n\nexport type ParticleDescriptorRecord =\n  | Readonly<{ type: 'between'; min: number; max: number }>\n  | Readonly<{ type: 'integer'; min: number; max: number }>\n  | Readonly<{ type: 'choice'; choices: readonly Readonly<{ value: unknown; weight: number }>[] }>\n  | Readonly<{ type: 'parameter'; name: string }>\n  | Readonly<{\n      type: 'curve';\n      keys: readonly (readonly [number, PibblParticleCurveValue])[];\n      options: PibblParticleCurveOptions | undefined;\n    }>\n  | Readonly<{\n      type: 'gradient';\n      keys: readonly (readonly [number, string])[];\n      options: PibblParticleCurveOptions | undefined;\n    }>;\n\nconst descriptorRecords = new WeakMap<object, ParticleDescriptorRecord>();\n\nfunction descriptor<T extends object>(value: T, record: ParticleDescriptorRecord): T {\n  const frozen = Object.freeze(value);\n  descriptorRecords.set(frozen, Object.freeze(record));\n  return frozen;\n}\n\nfunction assertFinite(value: number, label: string): void {\n  if (!Number.isFinite(value)) {\n    throw new RangeError(`${label} must be finite; received ${String(value)}.`);\n  }\n}\n\nfunction cloneFrozenValue<T>(value: T, seen = new WeakMap<object, unknown>()): T {\n  if (value === null || typeof value !== 'object') return value;\n  const existing = seen.get(value);\n  if (existing !== undefined) return existing as T;\n  if (Array.isArray(value)) {\n    const result: unknown[] = [];\n    seen.set(value, result);\n    for (const entry of value) result.push(cloneFrozenValue(entry, seen));\n    return Object.freeze(result) as T;\n  }\n  const prototype = Object.getPrototypeOf(value);\n  if (prototype !== Object.prototype && prototype !== null) return value;\n  const result: Record<string, unknown> = Object.create(prototype);\n  seen.set(value, result);\n  for (const [key, entry] of Object.entries(value)) {\n    result[key] = cloneFrozenValue(entry, seen);\n  }\n  return Object.freeze(result) as T;\n}\n\nfunction validateRange(min: number, max: number, label: string): void {\n  assertFinite(min, `${label} min`);\n  assertFinite(max, `${label} max`);\n  if (min > max) {\n    throw new RangeError(\n      `${label} bounds require min to be at most max; received ${String(min)} through ${String(max)}.`,\n    );\n  }\n}\n\nfunction curveValueDimension(value: PibblParticleCurveValue): 1 | 2 {\n  if (typeof value === 'number') {\n    assertFinite(value, 'particleCurve value');\n    return 1;\n  }\n  if (!Array.isArray(value) || value.length !== 2) {\n    throw new TypeError('particleCurve values must be finite numbers or two-dimensional vectors.');\n  }\n  assertFinite(value[0], 'particleCurve vector value[0]');\n  assertFinite(value[1], 'particleCurve vector value[1]');\n  return 2;\n}\n\nfunction validateKeyTimes(\n  keys: readonly (readonly [time: number, value: unknown])[],\n  label: string,\n): void {\n  if (keys.length === 0) throw new TypeError(`${label} keys must be nonempty.`);\n  if (keys[0]?.[0] !== 0 || keys.at(-1)?.[0] !== 1) {\n    throw new RangeError(`${label} keys must cover normalized time 0 through 1.`);\n  }\n  let previous = Number.NEGATIVE_INFINITY;\n  for (let index = 0; index < keys.length; index += 1) {\n    const time = keys[index]?.[0];\n    assertFinite(time as number, `${label} keys[${index}] time`);\n    if ((time as number) <= previous) {\n      throw new RangeError(`${label} key times must be strictly increasing.`);\n    }\n    previous = time as number;\n  }\n}\n\nfunction normalizeOptions(\n  options: PibblParticleCurveOptions | undefined,\n  label: string,\n): PibblParticleCurveOptions | undefined {\n  if (options === undefined) return undefined;\n  if (options.easing !== undefined && typeof options.easing !== 'function') {\n    throw new TypeError(`${label} options.easing must be a Pibbl easing function.`);\n  }\n  return Object.freeze({ easing: options.easing });\n}\n\nfunction between(min: number, max: number): PibblParticleRange {\n  validateRange(min, max, 'particleRange');\n  if (!Number.isFinite(max - min)) {\n    throw new RangeError('particleRange span must be finite.');\n  }\n  const value = { type: 'between' as const, min, max };\n  return descriptor(value, value);\n}\n\nfunction integer(min: number, max: number): PibblParticleIntegerRange {\n  validateRange(min, max, 'particleInteger');\n  if (!Number.isSafeInteger(min) || !Number.isSafeInteger(max)) {\n    throw new RangeError('particleInteger min and max must be safe integers.');\n  }\n  if (!Number.isSafeInteger(max - min + 1)) {\n    throw new RangeError('particleInteger inclusive span must be a safe integer.');\n  }\n  const value = { type: 'integer' as const, min, max };\n  return descriptor(value, value);\n}\n\nfunction choice<const T>(\n  choices: readonly Readonly<{ value: T; weight: number }>[],\n): PibblParticleChoice<T> {\n  if (choices.length === 0) {\n    throw new TypeError('particleChoice choices must be nonempty.');\n  }\n  let totalWeight = 0;\n  const copied = Object.freeze(choices.map(({ value, weight }, index) => {\n    if (!Number.isFinite(weight) || weight <= 0) {\n      throw new RangeError(\n        `particleChoice choices[${index}].weight must be positive and finite; received ${String(weight)}.`,\n      );\n    }\n    totalWeight += weight;\n    if (!Number.isFinite(totalWeight)) {\n      throw new RangeError('particleChoice total weight must be finite.');\n    }\n    return Object.freeze({ value: cloneFrozenValue(value), weight });\n  }));\n  const value = { type: 'choice' as const, choices: copied };\n  return descriptor(value, value as ParticleDescriptorRecord) as PibblParticleChoice<T>;\n}\n\nfunction parameter<const Name extends string>(\n  name: Name,\n): PibblParticleParameterReference<Name> {\n  if (typeof name !== 'string' || name.trim().length === 0) {\n    throw new TypeError('particleParameter name must be a nonempty string.');\n  }\n  const value = { type: 'parameter' as const, name };\n  return descriptor(value, value);\n}\n\nfunction curve<const T extends PibblParticleCurveValue>(\n  keys: readonly (readonly [time: number, value: T])[],\n  options?: PibblParticleCurveOptions,\n): PibblParticleCurve<T> {\n  validateKeyTimes(keys, 'particleCurve');\n  let dimension: 1 | 2 | undefined;\n  const copied = Object.freeze(keys.map(([time, value], index) => {\n    const currentDimension = curveValueDimension(value);\n    if (dimension !== undefined && dimension !== currentDimension) {\n      throw new TypeError(\n        `particleCurve keys[${index}] value dimension must match earlier keys.`,\n      );\n    }\n    dimension = currentDimension;\n    return Object.freeze([time, cloneFrozenValue(value)] as const);\n  }));\n  const normalizedOptions = normalizeOptions(options, 'particleCurve');\n  const value = {\n    type: 'curve' as const,\n    keys: copied,\n    ...(normalizedOptions === undefined ? {} : { options: normalizedOptions }),\n  };\n  return descriptor(value, {\n    type: 'curve', keys: copied, options: normalizedOptions,\n  }) as PibblParticleCurve<T>;\n}\n\nfunction gradient(\n  keys: readonly (readonly [time: number, color: string])[],\n  options?: PibblParticleCurveOptions,\n): PibblParticleGradient {\n  validateKeyTimes(keys, 'particleGradient');\n  const copied = Object.freeze(keys.map(([time, color], index) => {\n    if (typeof color !== 'string' || color.trim().length === 0) {\n      throw new TypeError(`particleGradient keys[${index}] color must be a nonempty string.`);\n    }\n    return Object.freeze([time, color] as const);\n  }));\n  const normalizedOptions = normalizeOptions(options, 'particleGradient');\n  const value = {\n    type: 'gradient' as const,\n    keys: copied,\n    ...(normalizedOptions === undefined ? {} : { options: normalizedOptions }),\n  };\n  return descriptor(value, {\n    type: 'gradient', keys: copied, options: normalizedOptions,\n  });\n}\n\n/** @internal Returns metadata only for descriptors created by this package instance. */\nexport function getParticleDescriptorRecord(value: unknown): ParticleDescriptorRecord | undefined {\n  return typeof value === 'object' && value !== null ? descriptorRecords.get(value) : undefined;\n}\n\n/**\n * Describes a continuous random range for particle sampling.\n *\n * @param min - Finite lower bound, no greater than max.\n * @param max - Finite upper bound; the span must also be finite.\n * @returns An immutable continuous sampling descriptor. See {@link PibblParticleRange}.\n *\n * @see {@link PibblParticleRange}\n */\nexport const particleRange = between;\n/**\n * Describes a random integer range for particle sampling.\n *\n * @param min - Inclusive lower bound, a safe integer.\n * @param max - Inclusive upper bound; the inclusive span must be a safe integer.\n * @returns An immutable integer sampling descriptor. See {@link PibblParticleIntegerRange}.\n *\n * @see {@link PibblParticleIntegerRange}\n */\nexport const particleInteger = integer;\n/**\n * Describes weighted choices sampled by a particle effect.\n *\n * @param choices - Nonempty weighted values; every weight and their total must be positive and\n * finite.\n * @returns An immutable descriptor containing copied choices. See {@link PibblParticleChoice}.\n *\n * @see {@link PibblParticleChoice}\n */\nexport const particleChoice = choice;\n/**\n * References a named parameter declared by a particle effect.\n *\n * @param name - Nonempty name of a parameter declared by the effect.\n * @returns A typed parameter reference. See {@link PibblParticleParameterReference}.\n *\n * @see {@link PibblParticleParameterReference}\n */\nexport const particleParameter = parameter;\n/**\n * Describes keyframed scalar or vector values over normalized particle lifetime.\n *\n * @param keys - Scalar or 2D-vector keys with strictly increasing normalized times, starting at 0\n * and ending at 1.\n * @param options - Optional segment easing. See {@link PibblParticleCurveOptions}.\n * @returns An immutable lifetime curve containing copied keys. See {@link PibblParticleCurve}.\n *\n * @see {@link PibblParticleCurveOptions}\n * @see {@link PibblParticleCurve}\n * @see {@link PibblParticleCurveValue}\n */\nexport const particleCurve = curve;\n/**\n * Describes keyframed colors over normalized particle lifetime.\n *\n * @param keys - Color keys with strictly increasing normalized times, starting at 0 and ending at\n * 1.\n * @param options - Optional segment easing. See {@link PibblParticleCurveOptions}.\n * @returns An immutable lifetime color gradient containing copied keys. See\n * {@link PibblParticleGradient} .\n *\n * @see {@link PibblParticleCurveOptions}\n * @see {@link PibblParticleGradient}\n */\nexport const particleGradient = gradient;\n\n/** @internal Legacy test convenience; not exported from the public package entry. */\nexport const particle = Object.freeze({\n  between,\n  integer,\n  choice,\n  parameter,\n  curve,\n  gradient,\n});\n"],
+  "mappings": "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",
+  "names": ["result", "value"]
+}

package/dist/features/particles/lib/random.d.ts

@@ -0,0 +1,16 @@
+export interface CompiledWeightedChoice<T> {
+    readonly values: readonly T[];
+    readonly cumulativeWeights: readonly number[];
+    readonly totalWeight: number;
+}
+export declare function hashEmitterName(name: string): number;
+export declare function mix32(value: number): number;
+export declare function sampleHash(seed: number, emitterHash: number, ordinal: number, channel: number): number;
+export declare function sampleUnit(seed: number, emitterHash: number, ordinal: number, channel: number): number;
+export declare function sampleBetween(unit: number, min: number, max: number): number;
+export declare function sampleInteger(unit: number, min: number, max: number): number;
+export declare function compileWeightedChoice<T>(choices: readonly Readonly<{
+    value: T;
+    weight: number;
+}>[]): CompiledWeightedChoice<T>;
+export declare function sampleWeightedChoice<T>(choice: CompiledWeightedChoice<T>, unit: number): T;

package/dist/features/particles/lib/random.js

@@ -0,0 +1,61 @@
+function hashEmitterName(name) {
+  let hash = 2166136261;
+  for (let index = 0; index < name.length; index += 1) {
+    hash = Math.imul(hash ^ name.charCodeAt(index), 16777619);
+  }
+  return hash >>> 0;
+}
+function mix32(value) {
+  value = (value ^ value >>> 16) >>> 0;
+  value = Math.imul(value, 2146121005) >>> 0;
+  value = (value ^ value >>> 15) >>> 0;
+  value = Math.imul(value, 2221713035) >>> 0;
+  return (value ^ value >>> 16) >>> 0;
+}
+function sampleHash(seed, emitterHash, ordinal, channel) {
+  let value = mix32(seed >>> 0 ^ emitterHash);
+  value = mix32(value ^ mix32(ordinal >>> 0));
+  return mix32(value ^ Math.imul(channel >>> 0, 2654435761)) >>> 0;
+}
+function sampleUnit(seed, emitterHash, ordinal, channel) {
+  return sampleHash(seed, emitterHash, ordinal, channel) / 4294967296;
+}
+function sampleBetween(unit, min, max) {
+  return min + unit * (max - min);
+}
+function sampleInteger(unit, min, max) {
+  return min + Math.floor(unit * (max - min + 1));
+}
+function compileWeightedChoice(choices) {
+  const values = [];
+  const cumulativeWeights = [];
+  let totalWeight = 0;
+  for (const choice of choices) {
+    values.push(choice.value);
+    totalWeight += choice.weight;
+    cumulativeWeights.push(totalWeight);
+  }
+  return Object.freeze({
+    values: Object.freeze(values),
+    cumulativeWeights: Object.freeze(cumulativeWeights),
+    totalWeight
+  });
+}
+function sampleWeightedChoice(choice, unit) {
+  const target = unit * choice.totalWeight;
+  for (let index = 0; index < choice.cumulativeWeights.length; index += 1) {
+    if (target < choice.cumulativeWeights[index]) return choice.values[index];
+  }
+  return choice.values[choice.values.length - 1];
+}
+export {
+  compileWeightedChoice,
+  hashEmitterName,
+  mix32,
+  sampleBetween,
+  sampleHash,
+  sampleInteger,
+  sampleUnit,
+  sampleWeightedChoice
+};
+//# sourceMappingURL=random.js.map

package/dist/features/particles/lib/random.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/particles/lib/random.ts"],
+  "sourcesContent": ["export interface CompiledWeightedChoice<T> {\n  readonly values: readonly T[];\n  readonly cumulativeWeights: readonly number[];\n  readonly totalWeight: number;\n}\n\nexport function hashEmitterName(name: string): number {\n  let hash = 0x811c9dc5;\n  for (let index = 0; index < name.length; index += 1) {\n    hash = Math.imul(hash ^ name.charCodeAt(index), 0x01000193);\n  }\n  return hash >>> 0;\n}\n\nexport function mix32(value: number): number {\n  value = (value ^ (value >>> 16)) >>> 0;\n  value = Math.imul(value, 0x7feb352d) >>> 0;\n  value = (value ^ (value >>> 15)) >>> 0;\n  value = Math.imul(value, 0x846ca68b) >>> 0;\n  return (value ^ (value >>> 16)) >>> 0;\n}\n\nexport function sampleHash(\n  seed: number,\n  emitterHash: number,\n  ordinal: number,\n  channel: number,\n): number {\n  let value = mix32((seed >>> 0) ^ emitterHash);\n  value = mix32(value ^ mix32(ordinal >>> 0));\n  return mix32(value ^ Math.imul(channel >>> 0, 0x9e3779b1)) >>> 0;\n}\n\nexport function sampleUnit(\n  seed: number,\n  emitterHash: number,\n  ordinal: number,\n  channel: number,\n): number {\n  return sampleHash(seed, emitterHash, ordinal, channel) / 0x1_0000_0000;\n}\n\nexport function sampleBetween(unit: number, min: number, max: number): number {\n  return min + unit * (max - min);\n}\n\nexport function sampleInteger(unit: number, min: number, max: number): number {\n  return min + Math.floor(unit * (max - min + 1));\n}\n\nexport function compileWeightedChoice<T>(\n  choices: readonly Readonly<{ value: T; weight: number }>[],\n): CompiledWeightedChoice<T> {\n  const values: T[] = [];\n  const cumulativeWeights: number[] = [];\n  let totalWeight = 0;\n  for (const choice of choices) {\n    values.push(choice.value);\n    totalWeight += choice.weight;\n    cumulativeWeights.push(totalWeight);\n  }\n  return Object.freeze({\n    values: Object.freeze(values),\n    cumulativeWeights: Object.freeze(cumulativeWeights),\n    totalWeight,\n  });\n}\n\nexport function sampleWeightedChoice<T>(\n  choice: CompiledWeightedChoice<T>,\n  unit: number,\n): T {\n  const target = unit * choice.totalWeight;\n  for (let index = 0; index < choice.cumulativeWeights.length; index += 1) {\n    if (target < choice.cumulativeWeights[index]!) return choice.values[index]!;\n  }\n  return choice.values[choice.values.length - 1]!;\n}\n"],
+  "mappings": "AAMO,SAAS,gBAAgB,MAAsB;AACpD,MAAI,OAAO;AACX,WAAS,QAAQ,GAAG,QAAQ,KAAK,QAAQ,SAAS,GAAG;AACnD,WAAO,KAAK,KAAK,OAAO,KAAK,WAAW,KAAK,GAAG,QAAU;AAAA,EAC5D;AACA,SAAO,SAAS;AAClB;AAEO,SAAS,MAAM,OAAuB;AAC3C,WAAS,QAAS,UAAU,QAAS;AACrC,UAAQ,KAAK,KAAK,OAAO,UAAU,MAAM;AACzC,WAAS,QAAS,UAAU,QAAS;AACrC,UAAQ,KAAK,KAAK,OAAO,UAAU,MAAM;AACzC,UAAQ,QAAS,UAAU,QAAS;AACtC;AAEO,SAAS,WACd,MACA,aACA,SACA,SACQ;AACR,MAAI,QAAQ,MAAO,SAAS,IAAK,WAAW;AAC5C,UAAQ,MAAM,QAAQ,MAAM,YAAY,CAAC,CAAC;AAC1C,SAAO,MAAM,QAAQ,KAAK,KAAK,YAAY,GAAG,UAAU,CAAC,MAAM;AACjE;AAEO,SAAS,WACd,MACA,aACA,SACA,SACQ;AACR,SAAO,WAAW,MAAM,aAAa,SAAS,OAAO,IAAI;AAC3D;AAEO,SAAS,cAAc,MAAc,KAAa,KAAqB;AAC5E,SAAO,MAAM,QAAQ,MAAM;AAC7B;AAEO,SAAS,cAAc,MAAc,KAAa,KAAqB;AAC5E,SAAO,MAAM,KAAK,MAAM,QAAQ,MAAM,MAAM,EAAE;AAChD;AAEO,SAAS,sBACd,SAC2B;AAC3B,QAAM,SAAc,CAAC;AACrB,QAAM,oBAA8B,CAAC;AACrC,MAAI,cAAc;AAClB,aAAW,UAAU,SAAS;AAC5B,WAAO,KAAK,OAAO,KAAK;AACxB,mBAAe,OAAO;AACtB,sBAAkB,KAAK,WAAW;AAAA,EACpC;AACA,SAAO,OAAO,OAAO;AAAA,IACnB,QAAQ,OAAO,OAAO,MAAM;AAAA,IAC5B,mBAAmB,OAAO,OAAO,iBAAiB;AAAA,IAClD;AAAA,EACF,CAAC;AACH;AAEO,SAAS,qBACd,QACA,MACG;AACH,QAAM,SAAS,OAAO,OAAO;AAC7B,WAAS,QAAQ,GAAG,QAAQ,OAAO,kBAAkB,QAAQ,SAAS,GAAG;AACvE,QAAI,SAAS,OAAO,kBAAkB,KAAK,EAAI,QAAO,OAAO,OAAO,KAAK;AAAA,EAC3E;AACA,SAAO,OAAO,OAAO,OAAO,OAAO,SAAS,CAAC;AAC/C;",
+  "names": []
+}

package/dist/features/particles/lib/sample.d.ts

@@ -0,0 +1,32 @@
+import type { CompiledEmitter2D } from "./compiler.js";
+import type { PibblParticleShape2D } from "./types.js";
+export interface ParticleSamplerPerformanceSnapshot {
+    readonly samples: number;
+    readonly sampleArrayAllocations: number;
+    readonly sampleObjectAllocations: number;
+}
+/** @internal Deterministic structural counters for the particle hot loop. */
+export declare function particleSamplerPerformanceSnapshot(): ParticleSamplerPerformanceSnapshot;
+export declare const enum Particle2DRegister {
+    Live = 0,
+    X = 1,
+    Y = 2,
+    VelocityX = 3,
+    VelocityY = 4,
+    SizeX = 5,
+    SizeY = 6,
+    Rotation = 7,
+    Red = 8,
+    Green = 9,
+    Blue = 10,
+    Alpha = 11,
+    AtlasFrame = 12
+}
+export interface ParticleBirthView {
+    readonly seed: number;
+    readonly ordinal: number;
+    readonly birthTimeMilliseconds: number;
+}
+export declare function sampleCircleRadius(unit: number, radius: number): number;
+export declare function sampleShape2D(shape: PibblParticleShape2D, unit0: number, unit1: number, _unit2: number, output: Float64Array, offset: number): void;
+export declare function sampleParticle2D(plan: CompiledEmitter2D, birth: ParticleBirthView, effectTimeMilliseconds: number, parameters: Readonly<Float64Array>, output: Float64Array): boolean;